Linux多进程编程
进程的状态
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.
模型
多进程代码区模型(其他区参见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种进程终止
-
正常终止:
- 从 main() 返回
- 调用 exit() / _exit() / _Exit()
- 最后一个线程从其启动例程返回
- 最后一个线程调用pthread_exit()
-
异常终止:
- 调用abort()
- 接到一个信号并终止
- 最后一个线程对取消请求作出响应
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;
}
