进程大杂烩

1、fork函数的使用

使用fork()函数创建一个进程
pid_t fork(void)
fork函数调用成功，返回两次
返回为0， 代表当前进程是子进程
返回为正数，代表当前进程为父进程

fork()函数运行后会创建一个进程，加上开始的进程一共有两个进程，会执行两次fork()函数之后的内容，两次的区别是pid号不同
 
  1 #include <sys/types.h>
  2 #include <unistd.h>
  3 #include <stdio.h>
  4 int main()
  5 {
  6         pid_t pid;
  7         pid_t pid2;
  8         pid = getpid();
  9
 10         printf("before fork, pid :%d\n", pid);
 11
 12         fork();
 13
 14         pid2 = getpid();
 15
 16         if (pid == pid2)
 17         {
 18                 printf("this is father, pid :%d\n", pid2);
 19         }
 20         else{
 21
 22                 printf("this is child, pid :%d\n", pid2);
 23         }
 24         return 0;
 25 }

  1 #include <sys/types.h>
  2 #include <unistd.h>
  3 #include <stdio.h>
  4 int main()
  5 {
  6         pid_t pid;
  7
  8         printf("father pid :%d\n", getpid());
  9
 10         pid = fork();
 11
 12
 13         if (pid > 0)
 14         {
 15                 printf("this is father, pid :%d\n", getpid());
 16         }
 17         else if(pid == 0) {
 18                 printf("this is child, pid :%d\n", getpid());
 19         }
 20         return 0;
 21 }

2、进程创建发生了什么事

发生了：将父进程的内容复制一份给子进程
在传统内核中，是复制P1的代码段，数据段，堆，栈这四个部分，注意是其内容相同。（拷贝一模一样的）

写时拷贝：（copy on wirte）
内核只为新生成的子进程创建虚拟空间结构，它们复制于父进程的虚拟空间结构，但是不为它们分配内存，而是共享父进程的物理内存，当父子进程有更改相应段的行为发生时，再为子进程相应段分配物理内存。

3、vfork函数创建进程

与fork的区别：
1、vfork使用父进程存储空间，不拷贝
2、vfork保证子进程先运行，当子进程调用exit()推出后，父进程才执行

先用fork创建一次进程，例如：

 1 #include <sys/types.h>
  2 #include <unistd.h>
  3 #include <stdio.h>
  4 int main()
  5 {
  6         pid_t pid;
  7
  8         pid = fork();
  9
 10
 11         if (pid > 0)
 12         {
 13                 while(1)
 14                 {
 15                         printf("this is father, pid :%d\n", getpid());
 16                         sleep(1);
 17                 }
 18         }
 19         else if(pid == 0)
 20         {
 21                 while(1)
 22                 {
 23                         printf("this is child, pid :%d\n", getpid());
 24                         sleep(1);
 25                 }
 26         }
 27         return 0;
 28 }
~

结果是father、child进程彼此争夺CPU，在彼此while(1)不断循环

现在用vfork()创建进程，例如：

  1 #include <sys/types.h>
  2 #include <unistd.h>
  3 #include <stdio.h>
  4 #include <stdlib.h>
  5 int main()
  6 {
  7         pid_t pid;
  8         int cnt = 0;
  9         pid = vfork();
 10
 11         if (pid > 0)
 12         {
 13                 while(1)
 14                 {
 15                         printf("cnt=%d\n", cnt);
 16                         printf("this is father, pid :%d\n", getpid());
 17                         sleep(1);
 18                 }
 19         }
 20         else if(pid == 0)
 21         {
 22                 while(1)
 23                 {
 24                         printf("this is child, pid :%d\n", getpid());
 25                         sleep(1);
 26
 27                         if (++cnt == 3)
 28                         {
 29                                 exit(0);
 30                         }
 31                 }
 32         }
 33         return 0;
 34 }

可见前期一直是子进程运行，运行三次后调用exit(0);正常退出后才轮到父进程运行，且在子进程里面修改的cnt的值在父进程中也“同步”修改，但并不是同步，是父子进程共用存储空间

4、进程退出

正常退出：
1、main函数调用return；
2、进程调用exit(0);标准C库；
3、进程调用_exit();或者_Exit()，属于系统调用；

补充：
1、进程最后一个线程返回
2、最后一个线程调用pthread_exit

异常退出：
1、调用abort
2、当进程收到某些信号时，如ctrl+c
3、最后一个线程对取消（cancellation）请求做出响应

5、父进程等待子进程退出（一）

父进程等待子进程退出
并收集子进程的退出状态

子进程退出状态不被收集，变成僵死进程（僵尸进程），状态是Z+(zombie)

父进程收集子进程退出状态，相关函数：

status参数：是一个整型数指针
非空：子进程退出状态放在它所指向的地址中
空： 不关心退出状态

代码实现一下：

  1 #include <sys/types.h>
  2 #include <unistd.h>
  3 #include <stdio.h>
  4 #include <stdlib.h>
  5 int main()
  6 {
  7         pid_t pid;
  8         int cnt;
  9         pid = fork();
 10
 11         if (pid > 0)
 12         {
 13                 while(1)
 14                 {
 15                         wait(NULL);///
 16                         printf("cnt=%d\n", cnt);
 17                         printf("this is father, pid :%d\n", getpid());
 18                         sleep(1);
 19                 }
 20         }
 21         else if(pid == 0)
 22         {
 23                 while(1)
 24                 {
 25                         printf("this is child, pid :%d\n", getpid());
 26                         sleep(1);
 27
 28                         if (++cnt == 3)
 29                         {
 30                                 exit(0);
 31                         }
 32                 }
 33         }
 34         return 0;
 35 }

加入了wait(NULL)等待，父进程就会一直阻塞，等待子进程退出后再运行，但是不会收集子进程的状态码，

如果我们想要知道子进程的退出码怎么办呢：

 #include 
 #include 
 #include 
 #include 
 int main()
{
           pid_t pid;
           int cnt;
           int status; /
           pid = fork();
 
          if (pid > 0)
          {
                  while(1)
                  {
                          wait(&status);/
                          printf("status = %d\n", status);/
                          printf("cnt=%d\n", cnt);
                          printf("this is father, pid :%d\n", getpid());
                          sleep(1);
                }
          }
          else if(pid == 0)
          {
                  while(1)
                  {
                          printf("this is child, pid :%d\n", getpid());
                          sleep(1);
 
                          if (++cnt == 3)
                          {
                                  exit(3);//
                          }
                  }
          }
          return 0;
}

我们在exit()里面写的退出码是3，但是通过wait获取的状态码并不是3，这是为什么呢
要想得到状态码，要通过宏来解析它

用于检查 wait() 和 waitpid() 两个函数返回终止状态的宏: 这两个函数返回的子进程状态都保存在status指针中，用以下3个宏可以检查该状态：
WIFEXITED(status): 若为正常终止, 则为真。此时可执行 WEXITSTATUS(status): 取子进程传送给exit或_exit参数的低8位.
WIFSIGNALED(status): 若为异常终止, 则为真。此时可执行 WTERMSIG(status): 取使子进程终止的信号编号.
WIFSTOPPED(status): 若为当前暂停子进程, 则为真。此时可执行 WSTOPSIG(status): 取使子进程暂停的信号编号

printf("status = %d\n", status);
改写为：
printf("status = %d\n", WEXITSTATUS(status));

6、父进程等待子进程退出（二）

再来细说wait()函数

如果其所有子进程都还在运行，则阻塞
如果一个子进程已终止，正等待父进程获取其终止状态，则取得该子进程的终止状态立即返回
如果它没有任何子进程，即立即出错返回

wait()与waitpid()的区别：
wait()使调用者阻塞
waitpid()有一个选项，可以使调用者不阻塞

对于waitpid()的参数：

参数值	说明
pid<-1	等待进程组号为pid绝对值的任何子进程。
pid=-1	等待任何子进程，此时的waitpid()函数就退化成了普通的wait()函数。
pid=0	等待进程组号与目前进程相同的任何子进程，也就是说任何和调用waitpid()函数的进程在同一个进程组的进程。
pid>0	等待进程号为pid的子进程。

参数	说明
WNOHANG	如果pid指定的子进程没有结束，则waitpid()函数立即返回0，而不是阻塞在这个函数上等待；如果结束了，则返回该子进程的进程号。
WUNTRACED	如果子进程进入暂停状态，则马上返回。

但是调用waitpid()，并且使用WNOHANG 参数的话，虽然父进程不会阻塞等待子进程结束，但是等子进程结束后会变成僵尸进程

7、孤儿进程

父进程如果不等待子进程退出，在子进程之前就结束了总结的生命，此时的子进程叫做孤儿进程
Linux避免系统存在过多孤儿进程，init进程收留孤儿进程，变成孤儿进程的父进程

8、exec族函数

exec族函数相当于就是调用打包好的程序，执行一个shell指令，详情可见博文

在A进程可以启动B进程，跳到B进程去执行

9、system函数

https://www.cnblogs.com/leijiangtao/p/4051387.html

10、popen()函数

https://blog.csdn.net/libinbin_1014/article/details/51490568

比system的好处：可以获取运行的输出结果

 #include 
 #include 
 #include 
 #include 
 int main()
{
          char ret[1024] = {0};
          FILE *fp;

          fp = popen("ps", "r");
          int nread = fread(ret, 1, 1024, fp);//读进ret数组，一次读一个，读1024次，从fp里面读

          printf("read ret %d byte, ret=%s\n", nread, ret);
          return 0;
}