linux之进程详解与操作编程

---程序终止

(1)正常终止：return、exit、_exit

(2)非正常终止：自己或他人发信号终止进程

---atexit注册进程终止处理函数

(1)实验演示

(2)atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）

atexit(func1);

(2)return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。

//return 0;
//exit(0);
_exit(0);

---环境变量

(1)export命令查看环境变量

(2)进程环境表介绍.每一个进程中都有一份所有环境变量构成的一个表格，也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组，用environ变量指向它。

(3)程序中通过environ全局变量使用环境变量

    extern char **environ;// 声明就能用
int i = 0;
while (NULL != environ[i])
{
printf("%s\n", environ[i]);
i++;
}

(4)我们写的程序中可以无条件直接使用系统中的环境变量，所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了。

(4)获取和设置指定环境变量函数getenv、setenv  //char *getenv(const char *name);

---进程ID

(1)getpid、getppid、getuid、geteuid、getgid、getegid

(2)实际用户ID和有效用户ID区别（可百度）

    p1 = getpid();
printf("pid = %d.\n", p1);
p2 = getppid();
printf("parent id = %d.\n", p2);

---fork的内部原理

(1)进程的分裂生长模式。如果操作系统需要一个新进程来运行一个程序，那么操作系统会用一个现有的进程来复制生成一个新进程。老进程叫父进程，复制生成的新进程叫子进程。

(2)fork的演示

(3)fork函数调用一次会返回2次，返回值等于0的就是子进程，而返回值大于0的就是父进程。

(4)典型的使用fork的方法：使用fork后然后用if判断返回值，并且返回值大于0时就是父进程，等于0时就是子进程。

(5)fork的返回值在子进程中等于0，在父进程中等于本次fork创建的子进程的进程ID。

int main(void)
{
pid_t p1 = -1;
p1 = fork();// 返回2次   //
if (p1 == 0)
{
// 这里一定是子进程
// 先sleep一下让父进程先运行，先死
sleep(1);
printf("子进程, pid = %d.\n", getpid());
printf("子进程, 父进程ID = %d.\n", getppid());
}
if (p1 > 0)
{
// 这里一定是父进程
printf("父进程, pid = %d.\n", getpid());
printf("父进程, p1 = %d.\n", p1);    //p1是子进程的pid
}
return 0;
}

---父子进程各自独立打开同一文件实现共享

(1)父进程open打开1.txt然后写入，子进程打开1.txt然后写入，结论是：分别写。原因是父子进程分离后才各自打开的1.txt，这时候这两个进程的PCB已经独立了，文件表也独立了，因此2次读写是完全独立的。

(2)open时使用O_APPEND标志看看会如何？实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来，实现分别写。

pid = fork();
if (pid > 0)
{
// 父进程中
        //fd = open("1.txt", O_RDWR);
fd = open("1.txt", O_RDWR | O_APPEND);
if (fd < 0)
{
perror("open");
return -1;
}
printf("parent.\n");
write(fd, "hello", 5);
sleep(1);
}
else if (pid == 0)
{
// 子进程
        //fd = open("1.txt", O_RDWR D);
fd = open("1.txt", O_RDWR | O_APPEND);
if (fd < 0)
{
perror("open");
return -1;
}
printf("child.\n");
write(fd, "world", 5);
sleep(1);
}

--总结

(1)父子进程间终究多了一些牵绊

(2)父进程在没有fork之前自己做的事情对子进程有很大影响，但是父进程fork之后在自己的if里做的事情就对子进程没有影响了。本质原因就是因为fork内部实际上已经复制父进程的PCB生成了一个新的子进程，并且fork返回时子进程已经完全和父进程脱离并且独立被OS调度执行。

(2)子进程最终目的是要独立去运行另外的程序

---进程的诞生

(1)进程0和进程1

(2)fork

(3)vfork

3.4.6.2、进程的消亡

(1)正常终止和异常终止

(2)进程在运行时需要消耗系统资源（内存、IO），进程终止时理应完全释放这些资源（如果进程消亡后仍然没有释放相应资源则这些资源就丢失了）

(3)linux系统设计时规定：每一个进程退出时，操作系统会自动回收这个进程涉及到的所有的资源（譬如malloc申请的内容没有free时，当前进程结束时这个内存会被释放，譬如open打开的文件没有close的在程序终止时也会被关闭）。但是操作系统只是回收了这个进程工作时消耗的内存和IO，而并没有回收这个进程本身占用的内存（8KB，主要是task_struct和栈内存）

(4)因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收，因此我们每个进程都需要一个帮助它收尸的人，这个人就是这个进程的父进程。

---僵尸进程

(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被成为僵尸进程。

(2)子进程除task_struct和栈外其余内存空间皆已清理

(3)父进程可以使用wait或waitpid以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。

(4)父进程也可以不使用wait或者waitpid回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏）

---孤儿进程

(1)父进程先于子进程结束，子进程成为一个孤儿进程。

(2)linux系统规定：所有的孤儿进程都自动成为一个特殊进程（进程1，也就是init进程）的子进程。

---父进程wait回收子进程

---wait的工作原理

(1)子进程结束时，系统向其父进程发送SIGCHILD信号

(2)父进程调用wait函数后阻塞

(3)父进程被SIGCHILD信号唤醒然后去回收僵尸子进程

(4)父子进程之间是异步的，SIGCHILD信号机制就是为了解决父子进程之间的异步通信问题，让父进程可以及时的去回收僵尸子进程。

(5)若父进程没有任何子进程则wait返回错误

---wait实战编程

(1)wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。

(2)wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。

对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的pid和退出状态。

(3)fork后wait回收实例

(4)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个宏用来获取子进程的退出状态。

WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）

WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）

WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。

int main(void)
{
pid_t pid = -1;
pid_t ret = -1;
int status = -1;
pid = fork();
if (pid > 0)
{
// 父进程
//sleep(1);
printf("parent.\n");
ret = wait(&status);
printf("子进程已经被回收，子进程pid = %d.\n", ret);
printf("子进程是否正常退出：%d\n", WIFEXITED(status));  //是否是return、exit、_exit终止的   返回值是1
printf("子进程是否非正常退出：%d\n", WIFSIGNALED(status));   //是否不是return、exit、_exit终止的   返回值是0
printf("正常终止的终止值是：%d.\n", WEXITSTATUS(status));   //子程序return的值
}
else if (pid == 0)
{
// 子进程
printf("child pid = %d.\n", getpid());
return 51;
//exit(0);
}
else
{
perror("fork");
return -1;
}
return 0;
}

---waitpid和wait差别

(1)基本功能一样，都是用来回收子进程

(2)waitpid可以回收指定PID的子进程

(3)waitpid可以阻塞式或非阻塞式两种工作模式

代码实例

pid = fork();
if (pid > 0)
{
// 父进程
sleep(1);
printf("parent, 子进程id = %d.\n", pid);
//ret = wait(&status);
//ret = waitpid(-1, &status, 0);  //使用waitpid实现wait的效果,-1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID
//ret = waitpid(pid, &status, 0);
   //等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为-1；如果成功回收了pid这个子进程则返回值为回收的进程的PID
ret = waitpid(pid, &status, WNOHANG);  //非阻塞式,这种表示父进程要非阻塞式的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。
printf("子进程已经被回收，子进程pid = %d.\n", ret);
printf("子进程是否正常退出：%d\n", WIFEXITED(status));
printf("子进程是否非正常退出：%d\n", WIFSIGNALED(status));
printf("正常终止的终止值是：%d.\n", WEXITSTATUS(status));
}
else if (pid == 0)
{
// 子进程
//sleep(1);
printf("child pid = %d.\n", getpid());
return 51;
//exit(0);
}
else
{
perror("fork");
return -1;
}

---竞态初步引入

(1)竞态全称是：竞争状态，多进程环境下，多个进程同时抢占系统资源（内存、CPU、文件IO）

(2)竞争状态对OS来说是很危险的，此时OS如果没处理好就会造成结果不确定。

(3)写程序当然不希望程序运行的结果不确定，所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制，我们需要做的是在合适的地方使用合适的方法来消灭竟态。

---为什么需要exec函数

(1)fork子进程是为了执行新程序(fork创建了子进程后，子进程和父进程同时被OS调度执行，因此子进程可以单独的执行一个程序，这个程序宏观上将会和父进程程序同时进行)

(2)可以直接在子进程的if中写入新程序的代码。这样可以，但是不够灵活，因为我们只能把子进程程序的源代码贴过来执行（必须知道源代码，而且源代码太长了也不好控制），譬如说我们希望子进程来执行ls -la 命令就不行了（没有源代码，只有编译好的可执行程序）

(3)使用exec族运行新的可执行程序（exec族函数可以直接把一个编译好的可执行程序直接加载运行）

(4)我们有了exec族函数后，我们典型的父子进程程序是这样的：子进程需要运行的程序被单独编写、单独编译连接成一个可执行程序（叫hello），（项目是一个多进程项目）主程序为父进程，fork创建了子进程后在子进程中exec来执行hello，达到父子进程分别做不同程序同时（宏观上）运行的效果。

(1)execl和execv  这两个函数是最基本的exec，都可以用来执行一个程序，区别是传参的格式不同。execl是把参数列表（本质上是多个字符串，必须以NULL结尾）依次排列而成（l其实就是list的缩写），execv是把参数列表事先放入一个字符串数组中，再把这个字符串数组传给execv函数。

(2)execlp和execvp 这两个函数在上面2个基础上加了p，较上面2个来说，区别是：上面2个执行程序时必须指定可执行程序的全路径（如果exec没有找到path这个文件则直接报错），而加了p的传递的可以是file（也可以是path，只不过兼容了file。加了p的这两个函数会首先去找file，如果找到则执行执行，如果没找到则会去环境变量PATH所指定的目录下去找，如果找到则执行如果没找到则报错）

(3)execle和execvpe 这两个函数较基本exec来说加了e，函数的参数列表中也多了一个字符串数组envp形参，e就是environment环境变量的意思，和基本版本的exec的区别就是：执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。

3.4.9.3、exec实战1

(1)使用execl运行ls -l -a

(2)使用execv运行ls

(3)使用execl运行自己写的程序

// 子进程
//execl("/bin/ls", "ls", "-l", "-a", NULL);// ls -l -a
char * const arg[] = {"ls", "-l", "-a", NULL};
execv("/bin/ls", arg);
//execl("hello", "aaa", "bbb", NULL);
char * const arg[] = {"aaa", "bbb", NULL};
execv("hello", arg);

---execlp和execvp

(1)加p和不加p的区别是：不加p时需要全部路径+文件名，如果找不到就报错了。加了p之后会多帮我们到PATH所指定的路径下去找一下。

---execle和execvpe

(1)main函数的原型其实不止是int main(int argc, char **argv)，而可以是

int main(int argc, char **argv, char **env)第三个参数是一个字符串数组，内容是环境变量。

(2)如果用户在执行这个程序时没有传递第三个参数，则程序会自动从父进程继承一份环境变量（默认的，最早来源于OS中的环境变量）；如果我们exec的时候使用execlp或者execvpe去给传一个envp数组，则程序中的实际环境变量是我们传递的这一份（取代了默认的从父进程继承来的那一份）

char * const envp[] = {"AA=aaaa", "XX=abcd", NULL};
execle("hello", "hello", "-l", "-a", NULL, envp);

---进程状态和system函数

---进程的5种状态

(1)就绪态。这个进程当前所有运行条件就绪，只要得到了CPU时间就能直接运行。

(2)运行态。就绪态时得到了CPU就进入运行态开始运行。

(3)僵尸态。进程已经结束但是父进程还没来得及回收

(4)等待态（浅度睡眠&深度睡眠），进程在等待某种条件，条件成熟后可进入就绪态。等待态下就算你给他CPU调度进程也无法执行。浅度睡眠等待时进程可以被（信号）唤醒，而深度睡眠等待时不能被唤醒只能等待的条件到了才能结束睡眠状态。

(5)暂停态。暂停并不是进程的终止，只是被被人（信号）暂停了，还可以回复的。

---进程各种状态之间的转换图

---system函数简介

(1)system函数 = fork+exec

(1)原子操作。原子操作意思就是整个操作一旦开始就会不被打断的执行完。原子操作的好处就是不会被人打断（不会引来竞争状态），坏处是自己单独连续占用CPU时间太长影响系统整体实时性，因此应该尽量避免不必要的原子操作，就算不得不原子操作也应该尽量原子操作的时间缩短。

(2)使用system调用ls