Linux多进程编程

时间：2024-01-21 17:49:52

进程的状态

Linux进程有7种基础状态(两种running算一种),除了traced都可以用$ps命令查看,$ps可以查看的进程状态如下，更多进程状态信息参见Linux Process VS Thread VS LWP

R running or runnable (on run queue)

D uninterruptible sleep (usually IO)

S interruptible sleep (waiting for an event to complete)

T stopped, either by a job control signal or because it is being traced.

W paging (not valid since the 2.6.xx kernel)

X dead (should never be seen)

Z defunct ("zombie") process, terminated but not reaped by its parent.

Linux多进程编程

模型

多进程代码区模型(其他区参见copy-on-write):

#include <sys/types.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/wait.h>

getpid()/getuid()/getgid()					//获得PID/UID/GID

fork()/vfork()								//创建子进程

exec() family								//替代子进程

atexit()/on_exit()/exit()/_exit()/_Exit()	//退出子进程

wait()/waitpid()							//获得子进程退出状态

getpid()、getppid()

//getpid() 返回调用进程的PID

//getppid() 返回调用进程的父进程的PID

pid_t getpid(void); 		//pid_t是int

pid_t getppid(void);

getuid()、geteuid()

getuid()返回调用进程的UID

geteuid()返回调用进程的effective UID

uid_t getuid(void); 		//uid_t是unsigned int

uid_t geteuid(void);

getgid()，getegid()

//getgid()返回调用进程的real GID

//getegid()返回调用进程的effective GID

id_t getgid(void); 		//gid_t是unsigned int

gid_t getegid(void);
printf("pid=%d\n",getpid());

	printf("ppid=%d\n",getppid());

	printf("uid=%d\n",getuid());

	printf("gid=%d\n",getgid());

}

fork()

//创建子进程，在父进程中返回子进程的PID，在子进程中返回0,失败在父进程中返回-1

pid_t fork(void);

fork()创建的子进程继承父进程的有:

  • 实际用户ID，实际组ID，有效用户ID，有效组ID
  • 附属组ID
  • 进程组ID
  • 会话ID
  • 控制终端
  • 设置用户ID标志和设置组ID标志
  • 当前工作目录
  • 根目录
  • 文件模式和安排
  • 信号屏蔽和安排
  • 对任一打开fd的close-on-exec
  • 环境
  • 连接的共享存储段
  • 存储映像
  • 资源限制

与父进程有区别的有

  • fork的返回值
  • PID
  • PPID
  • 子进程的tms_utime,tms_stime,tms_cutime,tms_ustime被设置为0
  • 不继承文件锁
  • 子进程未处理闹钟被清除
  • 子进程未处理信号集设置为空集

父子进程代码区执行次序

fork()产生的所有进程共享代码区,copy-on-write其他区)

  • fork()之前的代码, 由parent执行一次
  • fork()之后的代码, 由父子进程各执行一次
  • fork()的返回值由父子进程各自返回一次

copy-on-write:

fork()一下干的几件事:

  • 给P2分配Text段, Data段, Heap段, Stack段的虚拟地址,都指向P1中相应的物理地址
  • P2的Text段是铁定和P1共享同一个物理地址了, 剩下的Data,Heap,Stack待定
  • 如果one of them 改变了这三个段的内容, 就把原来的数据复制一份给P2, 这样P2就有了相应的新的物理地址
//创建任意多个进程:子进程干活，父进程创建一个爹一堆儿子

int i=0;

for(i=0;i<10;i++){	//创建10个进程, 只有parent在执行for()因为child在每次循环体内就exit()了

	pid_t pid=fork();

	if(-1==pid)

		perror("fork"),exit(-1);

	if(0==pid){

		…

		exit(0);	//终止子进程, 自然也就跳出了循环,防止再fork()

	}

}
#include<unistd.h>

#include<stdlib.h>

pid_t pid=fork();

if(-1==pid)

	perror(“fork”),exit(-1);

if(0==pid){

	//child process

	exit(0);

}

int main(){

	pid_t pid=fork();

	if(-1==pid)

		perror("fork"),exit(-1);

	printf("pid=%d\n",pid);

	if(0==pid){

		printf("I'm child,my PID:%d,my parent's PID:%d\n",getpid(),getppid());

		sleep(3);

		printf("I'm child,my PID:%d,my parent's PID:%d\n",getpid(),getppid());

	}else{

		sleep(1);

		printf("I'm parent,my PID:%d, my child's PID:%d\n",getpid(),pid);

	}

	return 0;

}

$./a.out

pid=2915

pid=0

I'm child,	  my PID:2915, my parent's PID:2914

I'm parent,my PID:2914, my child's   PID:2915

I'm child,  my PID:2915, my parent's PID:1	#一个Orphan

#卡在这, 因为两个进程抢一个终端,不是死循环,直接[ENTER]就行

vfork()

//创建一个空的子进程，父进程会等待子进程退出之后在继续执行,在子进程执行期间，父进程被挂起，此期间子进程和父进程共享所有的内存资源

//vfork()多用在在不拷贝父进程页表的情况下创建新的进程，单独使用没有多线程的价值, 主要和exec()搭配使用。

//子进程终止时不能从当前函数返回/调用exit函数, 可以调用_exit(), 该函数保证了子进程先于父进程执行

//当下很多系统已经不再支持vfork()函数

pid_t vfork(void);
int main(){

	pid_t pid=vfork();

	if(-1==pid)

		perror("vfork"),exit(-1);

	if(0==pid){

		printf("child %d starts\n",getpid());

		sleep(2);

		//跳转出去, 调用execl()

		int res=execl("./proc","proc",NULL);

		//"ls"表示执行方式, 以字符串的形式传进来

		if(-1==res)

			perror("execl"),_exit(-1);//ATTENTION,用_exit()

	}

	printf("parent starts\n");

	printf("parent ends\n");

	return 0;

}

//execl()可以跳出当前进程(VS fork()), 去执行一个完全不同的文件,可以帮助vfork()实现多进程,

//父进程结束了,系统就会显示[~/Desktop/160512/Code]$,此时发现从已经终结的子进程跳转出的的文件还没执行完, 再打印ls -l的内容

$./a.out

child 4258 starts

parent starts

parent ends

[~/Desktop/160512/Code]$total 20

-rw-rw-r-- 1 tarena tarena  754  5月 12 11:03 01waitpid.c

-rw-rw-r-- 1 tarena tarena  449  5月 12 10:31 02vfork.c

-rw-rw-r-- 1 tarena tarena  489  5月 12 11:28 03execl.c

-rwxrwxr-x 1 tarena tarena 7499  5月 12 11:28 a.out

*/

exec()

用一个新的进程影像替代当前的进程映像，失败返回-1设errno

extern char **environ;

int execl(const char *path, const char *arg, ...);

int execlp(const char *file, const char *arg, ...);

int execle(const char *path, const char *arg, ..., char * const envp[]);

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

ATTENTION: vfork()主要与exec family搭配使用, 主要用语子进程执行与父进程完全不同代码段的场合中, 其中vfork()专门用于创建进程, exec family 专门用于跳转执行

, fork()虽然也可以和exec family 搭配使用, 但是fork()会复制父进程的内存空间, 复制完了又跳出去, 没什么意义, 效率不如(vfork(), exec family)

#include<unistd.h>

#include<sys/types.h>

if(0==pid){

		int res=execl("./proc","proc",NULL);	//"ls"就是执行方式, 以字符串的形式传进来, “proc”也是

		if(-1==res)

			perror("execl"),_exit(-1);		//ATTENTION,vfork用_exit()

}

7种进程终止

  • 正常终止:

    1. 从 main() 返回
    2. 调用 exit() / _exit() / _Exit()
    3. 最后一个线程从其启动例程返回
    4. 最后一个线程调用pthread_exit()

  • 异常终止:

    1. 调用abort()
    2. 接到一个信号并终止
    3. 最后一个线程对取消请求作出响应

exit status VS termination status

退出状态exit status是我们传入到exit()，_exit(),_Exit()函数的参数。进程正常终止的情况下，内核将退出状态转变为终止状态以供父进程使用wait()，waitpid()等函数获取。终止状态termination status除了上述正常终止进程的情况外，还包括异常终止的情况，如果进程异常终止，那么内核也会用一个指示其异常终止原因的终止状态来表示进程，当然，这种终止状态也可以由父进程的wait(),waitpid()进程捕获。

exit()

//引起进程的正常终止，所谓正常终止是按照注册的反顺序依次调用atexit()和on_exit()里注册的函数。VS _exit()和_Exit()会立即终止进程

//进程终止后会传递退出码给父进程，这个"退出码&0377"可以被父进程的wait()系列函数捕获并解析。

//系统使用8位二进制表示进程退出号,就是0~255,这也是为什么exit()返回status&0377给父进程的原因, 其实是取低八位二进制. 如果exit(10000),实际返回的就是16.

void exit(int status);

atexit()

//注册一个正常终止进程时执行的函数，这个函数的参数必须是void，注册成功返回0,失败返回非0

int atexit(void (*function)(void));	//参数是函数指针

on_exit()

//和atexit()类似,用于注册exit()时执行的函数, 不同之处是on_exit注册的函数可以带参数，这个function的两个形参分别是通过exit()传入的int型 和 通过on_exit()传入的*arg

//同一个函数可以被多次注册，注册一次退出进程时就会被执行一次

//fork()出的子进程会继承父进程的注册函数，但一旦调用了exec()，所有注册的函数都会被移除

//成功返回0,失败返回非0

int on_exit(void (*function)(int , void *), void *arg);
#include<stdlib.h>

void fa(int status,void* pv){

	printf("obtained status=%d\n",status);

	free(pv);

	pv=NULL;

}

int main(){

	pid_t pid=fork();

	if(0==pid){

		…

		int *pi=(int*)malloc(sizeof(int));	//没有错误处理

		if(0!=on_exit(fa,pi))

			perror("on_exit"),exit(-1);

		…

		exit(100); //terminate child and free dynamic memory automatically

	}

}

_exit()/_Exit():

//立即终止调用的进程，所有的子进程都会挂到PID1下，父进程会收到SIGCHLD信号，还可以用wait()接收退出码

void _exit(int status);		//<unistd.h>

void _Exit(int status);		//<stdlib.h>
#include<unistd.h>

#include<sys/types.h>

#include<stdio.h>

#include<stdlib.h>

void fa(){

	printf("所有需要善后处理的工作都可以交给我哦!\n");

}

int main(){

	int res=atexit(fa);

	if(0!=res)

		perror("atexit"),exit(-1);

	printf("main start\n");

	_exit(0);      	//立即终止,如果这句话留着fa()不会执行

	printf("main end\n");

	return 0;		//把_exit()注释掉就会执行fa()

}

Orphan VS Zombie

Orphan Process：一个parent退出，而它的一个或多个child还在运行，那么这些child将成为orphan。将被init(PID==1)收养，并由init对它们完成状态收集工作。init会循环地wait()直到这些child完成了他们的工作. 即当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和*出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

Zombie Process: 一个使用fork()创建的child，如果child退出，而parent并没有调用wait/waitpid获取child的状态信息，那么child的process descriptor、PID和PCB等资源仍然保存在系统中。此时的child就变成了zombie。因为系统的PID总数是有限的, parent不断的创建child而不去wait,系统早晚会被拖垮.

总结:

  • Orphan/Zombie都是因为在parent中没有wait掉child, 不同之处是orphan的parent已经没了, 由init来接管了,而zombie有个缺德的parent, 不wait还不撒手,拖累了系统
  • $ps 一下Zombie的进程状态是’Z’

wait(), waitpid(), waitid()

//wait for process to change state

//wait()挂起父进程，直到一个子进程结束

//waitpid()挂起父进程，直到指定的子进程终止

//wait()相当于waitpid(-1, &status, 0)

//成功返回子进程的PID，失败返回-1设errno

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);

/* pid in waitpid() and kill()

pid>0	//指定pid

pid=0	//GID是调用进程PID的子进程

pid=-1	//任何子进程

pid<-1	//GID是PID的子进程

*/

/*options(Bitwaise Or)

WNOHANG     	//如果没有子进程终止就立即返回return immediately if no child has exited.

WUNTRACED   	//如果一个子进程stoped且没有被traced，那么立即返回

WCONTINUED (since Linux 2.6.10) //如果stoped的子进程通过SIGCONT复苏，那么立即返回

*/

/*

如果退出不是NULL，wait()会使用形参指针带出退出码，这个退出码可以使用下列宏解读

WIFEXITED(status)		//如果子进程正常退出返回真

WEXITSTATUS(status)		//返回子进程的退出码，当且仅当WIFEXITED为真时有效

WIFSIGNALED(status)		//如果子进程被一个信号终止时返回真

WTERMSIG(status)		//返回终止子进程的信号编号，当且仅当WIFSIGNALED为真时有效

WCOREDUMP(status)		//如果子进程导致了"核心已转储"则返回真，当且仅当WIFSIGNALED为真时有效r

WIFSTOPPED(status)		//如果子进程被一个信号暂停时返回真，当且仅当调用进程使用WUNTRACED或子进程正在traced时有效

WSTOPSIG(status)		//返回引起子进程暂停的信号编号，当且仅当WIFSTOPPED为真时有效

WIFCONTINUED(status)(since Linux 2.6.10)//如果子进程收到SIGCONT而复苏时返回真

*/
if(0==pid){

	…

	exit(100);		//把child的退出状态信息设为100

}

int status=0;

int res=wait(&status);	//status用来接收结果

if(-1==res)

	perror("wait"),exit(-1);

if(WIFEXITED(status))				//ATTENTION:这个宏要int不是int*,和wait不一样

	printf("child%d end normally, status is:%d\n",res,WEXITSTATUS(status));	//将打印出exit()里的状态

例子

/*------

file.c

------*/

#include<unistd.h>

#include<fcntl.h>

#include<sys/types.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

int main(){

	int fd=open("a.txt",O_RDWR|O_TRUNC|O_CREAT,0664);

	pid_t pid=fork();

	if(-1==pid)

		perror("fork"),exit(-1);

	if(0==pid){

		printf("child:%d start\n",getpid());

//		char buf[]="world";		//这个变量没必要,常量就行

		int res=write(fd,"hello",sizeof("hello"));

		if(-1==res)

			perror("child write"),exit(-1);

		res=close(fd);			//child把parent的数据复制过来,所以fd需要关闭

		if(-1==res)

			perror("child close"),exit(-1);

		printf("parent:%d end\n",getpid());

		exit(0);

	}

	printf("parent:%d start\n",getpid());

	sleep(1);

	int res=write(fd,"world",sizeof("world"));

	if(-1==res)

		perror("parent write"),exit(-1);

	res=close(fd);

	if(-1==res)

		perror("parent close"),exit(-1);

	printf("parent:%d end\n",getpid());

	return 0;

}

Note:

  • 运行结果a.txt两个进程没有覆盖=>父子进程使用的读写位置信息是同一份=>文件表是同一份=>但是两个是不同的fd, 所以fork()创建子进程也会复制一个文件描述符总表
  • 正是因为使用读写一次 offset会向后移, 所以没有覆盖, 因为后来的是使用前面留下的offset的位置, 所以使用的读写信息是一样的
/*--------------------------------------------

child终止时自动释放malloc()

----------------------------------------------*/

#include<unistd.h>

#include<sys/types.h>

#include<stdio.h>

#include<stdlib.h>

#define PI 3.141592657

int *ipdata=NULL;

///*

void fa(){

	free(ipdata);

	ipdata=NULL;

}

//*/

int main(){

	pid_t pid=fork();

	if(-1==pid)

		perror("fork"),exit(-1);

	if(0==pid){

		printf("1");

		printf("child starts\n");

		ipdata=(int*)malloc(sizeof(int));

		if(NULL==ipdata)

			printf("malloc fails\n");

//			perror("malloc"),exit(-1);	//???

//		*ipdata=data;

		int res=atexit(fa);

		if(0!=res){

			printf("atexit fails\n");

			exit(EXIT_FAILURE);

		}

		printf("Please input a radius:");

		scanf("%d",ipdata);

		printf("primeter is:%lf\n",2*PI*(*ipdata));

		exit(EXIT_SUCCESS);

	}

	printf("parent starts\n");

	int stat=0;

	pid=wait(&stat);

	if(WIFEXITED(stat))

		printf("child has terminated,its status:%d\n",WEXITSTATUS(stat));

	return 0;

}

Note:

  • 用全局变量做桥梁
  • atexit()里面的函数一定是int *(void)函数的形参列表变了也不行
  • ATTENTION: vfork()的child虽然整个内存区都是和parent共享的, 但是变量的作用域还是在啊, 所以你跨函数使用变量肯定要传参的啊
/*--------------------------------------------

on_exit.c, child终止时自动释放malloc()

----------------------------------------------*/

#include<unistd.h>

#include<sys/types.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<stdio.h>

#include<stdlib.h>

#include<signal.h>

void fa(int status,void* pv){

	printf("obtained status=%d\n",status);

	free(pv);

	pv=NULL;

}

int main(){

	//创建子进程,使用fork()

	pid_t pid=fork();

	if(-1==pid){

		printf("parent starts%d\n",pid);

	}

	if(0==pid){

		printf("child starts%d\n",getpid());

		int *pi=(int*)malloc(sizeof(int));

		if(NULL==pi)

			printf("malloc error"),exit(-1);

		//use on_exit()register function

		if(0!=on_exit(fa,pi))

			perror("on_exit"),exit(-1);

		printf("please input a radius(int)\n");

		scanf("%d",pi);

		printf("the primeter is:%lf\n",2*3.14*(*pi));

		//terminate child and free dynamic memory automatically

		exit(100);

	}

	//父进程等待子进程终止, 获取退出状态

	int status=0;

	int res=waitpid(pid,&status,0);

	if(-1==res)

		perror("waitpid"),exit(-1);

	if(WIFEXITED(status))

		printf("status of child:%d\n",WEXITSTATUS(status));

	return 0;

}

相关文章