系统启动进程0,进程0只负责启动进程1(init进程)或启动进程1和进程2;
其他进程都是由进程1或进程2启动的;
Unix用进程的PID标识进程,PID的本质就是一个整数;
每个进程都有一个唯一的进程ID(PID),在同一时刻进程的PID不会重复;进程的PID可以延时重用;
几个常用函数
getpid() 取当前进程的PID
getppid() 取父进程的PID
getuid()/geteuid() 取当前用户ID(有效用户ID)
启动子进程的函数
fork() 通过复制父进程来启动子进程;
vfork()+execl() 启动一个全新的子进程,有自己的一套;
fork()创建子进程(简单的复杂函数);
pid_t fork(void);
fork无参,返回PID;
fork()函数通过复制父进程,创建子进程;会复制除代码区之外的所有内存区域,代码区父子进程共享;
/*
* fork()函数初探
*/
#include <unistd.h>
#include <stdio.h>
int main() {
printf("begin\n");
pid_t pid = fork();
printf("end, pid = %d\n", pid);
return 0;
}
子进程是父进程的拷贝,即子进程从父进程得到了除代码区之外的数据段和堆栈段,这些需要分配新的内存;而对于只读的代码段,通常使用共享内存的方式访问;fork()返回后,父子进程都从调用fork()函数的下一条语句开始执行;
fork()之前的代码只有父进程执行一次,fork()之后的代码父子进程都各执行一次(执行2次);
fork()函数有两次返回,父进程返回子进程的PID,子进程返回0;
/*
* fork()函数返回值可以区分出父子进程
*/
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
int main() {
printf("begin\n");
pid_t pid = fork(); //pid可以区分出父子进程;
//父进程返回子进程的PID,子进程返回0;
if (pid == -1) {
perror("fork"), exit(-1);
}
//练习父子进程打印不同的内容
//父进程打印1,子进程打印2
//在父子进程中打印对方进程的ID;
if (pid == 0) {
//父子进程都会做判断,子进程满足条件
printf("2\n");
printf("我是子进程%d,父进程是%d\n", getpid(), getppid());
} else {
//父进程执行的分支;
printf("1\n");
printf("我是父进程%d,子进程是%d\n", getpid(), pid);
}
//if/else语句父子进程都执行,但是由于条件不同各自执行的部分不同
printf("end, pid = %d\n", pid);
return 0;
}
/*
* fork()创建的父子进程内存空间相互独立
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int i1 = 10;
int main() {
int i2 = 10; //i2子进程复制
char *str = malloc(10);
strcpy(str, "abcd");
pid_t pid = fork();
printf("pid = %d\n", pid);
/* 在父进程中返回子进程的PID,在子进程中返回0; */
if (pid == 0) {
printf("我是子进程fork()返回%d\n", pid);
} else {
printf("我是父进程fork()返回%d\n", pid);
}
/* i3父子进程分别创建; */
int i3 = 10;
if (pid == 0) {
/* 子进程执行分支 */
/* i1,i2子进程会复制 */
/* i3是父子进程分别创建的,不是复制的 */
i1 = 20, i2 = 20, i3 = 20;
str[0] = '1';
printf("child:i1=%d,i2=%d,i3=%d,str=%s\n", i1, i2, i3, str);
printf("chaddr:&i1=%p,&i2=%p,&i3=%p,&str=%p\n", &i1, &i2, &i3, str);
exit(0);
/* 执行后保证后面的不会执行 */
}
sleep(1);
printf("father:i1=%d,i2=%d,i3=%d,str=%s\n", i1, i2, i3, str);
printf("faaddr:&i1=%p,&i2=%p,&i3=%p,&str=%p\n", &i1, &i2, &i3, str);
/* 每个进程都有自己独立的虚拟内存空间; */
/* 子进程复制了父进程的内存空间,虚拟地址相同,
* 但属于不同进程 */
return 0;
}
fork()函数创建子进程后,父子进程谁先运行不确定,不同的系统有不同的算法;谁先结束也不确定;
fork()创建子进程时,如果父进程有文件描述符,子进程会复制文件描述符,但不复制文件表;
/*
* fork()创建子进程时,如果父进程有描述符,
* 子进程会复制文件描述符,但不复制文件表
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
int main() {
//pid_t pid = fork(); //父子进程将分别创建文件描述符
int fd = open("test.txt", O_RDWR | O_CREAT | O_TRUNC, 0666); if (fd == -1) {
perror("open"), exit(-1);
}
pid_t pid = fork(); //子进程复制文件描述符
/* 复制文件描述符,不复制文件表 */
if (pid == 0) {
/* 子进程执行分支 */
printf("child:fd=%d\n", fd);
write(fd, "abc", 3);
close(fd); //关闭子进程的fd
exit(0); //执行后保证后面的不会执行
}
sleep(1);
printf("father:fd=%d\n", fd);
write(fd, "123", 4);
/* 如果两个文件描述符对应同一个文件表,
* 文件位置偏移量是同一个,内容不会相互覆盖;
* 说明没有复制文件表 */
close(fd); //关闭父进程的fd
/* close()只删除对应关系,只有当文件描述符和文件表的对应关系为为0时才删除文件表 */
return 0;
}
父子进程之间的关系
fork()之后,父子进程同时运行,如果子进程先结束,子进程给父进程发一个信号,父进程负责回收子进程的资源;
fork()之后,父子进程同时运行,如果父进程先结束,子进程变成孤儿进程,会认进程1(init进程)做新的父进程;init进程叫孤儿院;
fork()之后,父子进程同时运行,如果子进程发信号时出现了问题,或者父进程没有及时处理信号,子进程就会变成僵尸进程Z;
fork()出现错误的原因
1系统进程总数有限额;
2用户进程总数有限额;
一般情况下,不可能超限额,因此fork()可以不判断-1,fork()出错的后果就是子进程创建失败,父进程继续执行;
练习
验证如果父进程先结束,子进程会以init进程做新的父进程;
思路
父进程先sleep(),运行子进程,子进程打印此时的父进程PID,然后子进程再sleep(),父进程结束后,子进程再次打印父进程的PID;
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
printf("父进程pid=%d\n", getpid());
pid_t pid = fork();
if (pid == 0) {
printf("父进程PID=%d\n", getppid());
sleep(2);
printf("父进程PID=%d\n", getppid());
} else {
printf("pid = %d\n", pid);
sleep(1);
printf("父进程%d结束\n", getpid());
/* ./a.out的父进程是bash的子进程,
* 结束后bash就会打印一次终端提示符 */
}
return 0;
}
进程的结束/终止
进程可能是正常结束也可能是非正常结束;
进程终止的5种正常情况
1> 主函数main()中执行 return 语句;
2> 函数 exit()可以终止进程;
3> _exit()/_Exit()可以终止进程;
4> 进程的最后一个线程执行了return返回语句(结束);
5> 进程的最后一个线程调用pthread_exit()函数(结束);
非正常结束进程的方法
1> 被信号终止;
2> 主线程被其他线程取消;
return 和 exit()区别:
return 是用来退出函数的;
exit() 是用来退出进程的;
exit()/_exit()/_Exit()的区别
The function _exit() terminates the calling process "immediately".
exit()函数定义在stdlib.h中,而_exit()定义在unistd.h中;
exit()被调用时不会立即结束进程,会先调用exit_handler并调用atexit()/on_exit()注册过的函数之后再结束进程;
_exit()/_Exit()在底层是一样的,没有区别; _Exit()立即结束进程;
_exit()函数只为进程实施内核清理工作;子进程中最好用_exit(),而exit()会影响父进程的状态;
atexit(函数指针)允许进程在结束之前调用其他函数,但如果用_Exit()结束进程时不调用;
int atexit(void (*func)(void))
可以注册多个函数,一个函数也可注册多次,按FILO顺序执行;
函数注册后,无法取消注册;
在清理函数中调用exit()在Linux中会继续执行剩下的清理函数但在某些系统可能出现死循环;
子进程会继承父进程的清理函数;
/*
* atexit()/exit()演示
*/
#include <stdio.h>
#include <stdlib.h>
void func1() {
printf("func1 is called\n");
}
void func2() {
printf("回收资源,善后处理\n");
}
int main() {
atexit(func1); //只注册func1(),只有在exit()时才调用;
atexit(func2); //atexit()的参数是函数指针,可以多次调用;
printf("begin\n");
/* exit()不会立即结束,可以调用atexit()注册过的函数再结束进程; */
exit(0); //参数是退出码,可以用来记录退出情况;
_Exit(0); //立即结束,不掉用fa;
printf("end\n");
return 0;
}
exit(0);//如何取退出码?
The exit() function causes normal process termination and the value of status & 0377 is returned to the parent (see wait(2)).
退出码返回给父进程;必须保证子进程先结束,父进程才能拿退出码;
函数wait()/waitpid()用于让父进程等待子进程的结束,并取得子进程的退出信息;
wait()/waitpid()就是让父进程等待子进程
1-> 如果所有子进程都在运行,父进程阻塞;
2-> 如果有一个子进程结束,父进程取得子进程的退出信息并返回,父进程继续运行;
3-> 如果没有子进程,父进程直接返回,继续运行;
注:僵尸子进程用wait()/waitpid()回收;僵尸进程是已经终止但资源没有被回收的进程;所以wait()/waitpid()函数又叫殓(lian)尸工;
如果一个子进程已经终止并且是僵尸进程,wait()会立即返回并取得该子进程的状态,否则阻塞;
二者的区别是
在一个子进程终止前,wait()使其调用者阻塞,而waitpid()提供更多选择;
pid_t wait(int *status);//参数是status的地址
wait()会让父进程等待任意子进程的结束,返回结束的子进程的PID,并把子进程的退出信息(是否正常退出和退出码)放入参数status参数中;
是否正常退出可以用WIFEXITED(status)判断,
退出码用WEXITSTATUS(status)获取0-255;
/*
* wait()函数演示
*/
#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
printf("current pid = %d\n", getpid());
pid_t pid = fork(); //pid只是fork的返回值
if (pid == 0) {
/* 子进程执行的分支 */
printf("child pid = %d\n", getpid());
sleep(1);
printf("child end\n");
exit(10);
}
int stat;
pid_t wpid = wait(&stat);
/* 等待任意一个子进程的结束,
* 参数为子进程退出码的地址
* 返回等到的子进程的PID */
printf("father go on\n");
printf("endchild pid = %d\n", wpid);
/* 判断子进程是否正常将结束 */
if (WIFEXITED(stat)) {
/* stat不能是指针,只能是数 */
printf("进程是正常结束\n");
/* 返回子进程的退出码 */
printf("exit code: %d\n", WEXITSTATUS(stat));
}
return 0;
}
pid_t waitpid(pid_t pid, int *status, int options);
可以等待指定的子进程;
在等待的过程中父进程可以阻塞也可以不阻塞;
参数
pid可以指定等待哪个/哪些子进程;
options可以指定等待时是否阻塞;
pid的值
-1,等待任意一个子进程的结束;
>0,等待特定的子进程结束(子进程PID=pid);
0,等待本进程组的子进程结束;
<-1,等待进程组ID等于pid绝对值的子进程;
options的值
0代表阻塞;
WNOHANG代表非阻塞;如果options用了WNOHANG,返回有三种
正数 等待到结束的子进程PID;
0 没有子进程结束,直接返回;
-1 出错了;
exit()不论参数是多少,都是正常结束进程,但一般用负数表示没有完成相关的功能;
/*
* waitpid()函数练习
* 一个父进程创建两个子进程
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid1 = fork();
pid_t pid2;
if (pid1 > 0) {
/* 父进程创建第2个子进程; */
pid2 = fork();
}
if (pid1 == 0) {
/* 子进程1执行的分支 */
printf("pid1 = %d\n", getpid());
sleep(1);
printf("pid1 end\n");
exit(-1);
}
if (pid2 == 0) {
/* 子进程2执行的分支 */
printf("pid2 = %d\n", getpid());
sleep(3);
printf("pid2 end\n");
exit(20);
}
int stat;
/* 在父进程中pid2是第2个子进程的pid,不是0; */
pid_t wpid = waitpid(pid1 /*-1*/ , &stat, 0);
/* -1等待任意一个子进程,>0等待特定的子进程; */
/* 0代表阻塞, WNOHANG代表非阻塞; */
printf("father end\n");
printf("wpid = %d\n", wpid);
if (WIFEXITED(stat)) {
printf("进程正常结束\n");
printf("exit code: %d\n", WEXITSTATUS(stat));
}
printf("end\n");
return 0;
}
wait()和waitpid()的区别
wait()是等待任意一个子进程的结束,等待过程必然阻塞;
waitpid()可以等待指定的子进程结束(也可以任意),等待过程中父进程可以阻塞也可以不阻塞;
创建子进程的两种方式
1-> fork() 复制父进程,创建子进程;
2-> vfork()+execl() 创建全新的子进程;
pid_t vfork(void);
create a child process and block parent;
vfork()从语法上看,和fork()一样;但机制和fork()完全不同;
vfork()不会复制父进程的任何资源;子进程会占用父进程的资源运行,父进程阻塞;直到子进程调用exec系列函数(比如:execl())或者子进程结束,资源就会还给父进程,解除父进程阻塞;
用execl()函数可以让父子进程并行;
vfork()函数只能创建新进程,但不提供程序;
execl()只提供程序,不创建新的进程;
vfork()+execl()既有进程,又有执行的程序;
fork()和vfork()函数的区别
fork()要拷贝父进程的数据段;而vfork()不需要完全拷贝父进程的数据段,在子进程没有调用exec和exit()之前,子进程与父进程共享数据段;
fork()不对父子进程的执行次序进行任何限制;而在vfork()调用中,子进程先运行,父进程挂起,直到子进程调用了exec或exit()之后,父子进程的执行次序才不再有限制;
vfork()创建的子进程一定先于父进程运行,直到子进程运行了execl()函数才能同时运行;
vfork()创建的子进程,如果不调用exec系列函数,必须用exit()强行退出,否则死循环;
若使用vfork()在调用exec系列函数后,还要使用exit()函数,防止exec系列函数启动失败导致的死循环;
/*
* vfork函数演示
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
/* pid_t pid = fork(); */
pid_t pid = vfork();
/* vfork()创建的子进程会阻塞父进程并占用父进程资源 */
if (pid == 0) {
/* 子进程执行的分支; */
sleep(1);
printf("child\n");
/* vfork()创建的子进程,如果不调用exec系列函数,
* 必须用exit()强行退出,否则死循环; */
exit(0);
}
printf("father\n");
return 0;
}
execl()函数负责启动一个全新的程序;
格式
int execl(const char *path, const char *arg, ...);
第1个参数是程序的全路径(路径/程序名),一定不能错;
第2个参数是执行程序的命令(可以错),
后面还可以跟可选参数,一般是选项或参数等,最后以NULL结束;
失败返回-1,失败就意味着没有启动新程序;
如果启动成功直接启动命令并退出,后面的语句不执行;
注:execl()函数不会改变进程的PID,只会改变进程执行的代码(全新的程序);
/*
* execl()函数演示
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
printf("begin\n");
int res = 0;
/* 路径如果错误,启动失败;命令错误没有关系; */
res = execl("/bin/ls", "ls", NULL);
/* res = execl("/bin/ls", "ls", "../", NULL); */
/* res = execl("/bin/ls", "ls", "-al", "../", NULL); */
/* 第1个参数表示程序路径,第2个参数就是命令; */
/* 后面是可选参数; */
/* 最后一个参数要为NULL; */
printf("res = %d\n", res);
printf("end\n");
return 0;
}
vfork()+execl()练习
/*
* vfork保证子进程先运行,
* 子进程执行到execl时父子进程同时运行;
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
pid_t pid = vfork();
if (pid == 0) {
/* 子进程执行的分支; */
sleep(1);
execl("/bin/pwd", "pwd", NULL); //立刻将资源还给父进程;
printf("child execl() failed\n");
exit(0); //防止execl启动失败导致的死循环;
}
printf("father\n");
return 0;
}
验证execl()不启动新进程,只提供程序;
思路
用vfork()创建子进程,在调用execl()函数之前打印vfork()创建的子进程PID,在execl()调用程序中打印一些子进程的PID,如果两个相等,意味着execl()没有创建新的子进程;
打印PID的子进程的程序自己写一个;
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
printf("current pid = %d\n", getpid());
pid_t pid = vfork();
if (pid == 0) {
/* 子进程执行的分支; */
//sleep(1);
printf("main child pid = %d\n", getpid()); //获取进程PID
printf("马上执行execl()\n");
/* 首先编写打印自己pid的程序并编译为printpid.o */
execl("./printpid.o", "printpid", NULL); //立刻将资源还给父进程;
exit(0); //防止execl启动失败导致的死循环;
}
printf("father is running ...\n");
waitpid(pid, NULL, 0); //让父进程等待子进程结束,防止僵尸进程
printf("father go on\n");
return 0;
}
/*
* 打印自己pid的函数
* gcc 07printpid.c -o printpid.o
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
printf("我是execl中调用的子函数pid = %d\n", getpid());
return 0;
}