进程大杂烩

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的代码段,数据段,堆,栈这四个部分,注意是其内容相同。(拷贝一模一样的)
进程大杂烩_第1张图片

写时拷贝:(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 }
~

进程大杂烩_第2张图片
结果是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 }

进程大杂烩_第3张图片
可见前期一直是子进程运行,运行三次后调用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、父进程等待子进程退出(一)

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

进程大杂烩_第4张图片

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

父进程收集子进程退出状态,相关函数:
进程大杂烩_第5张图片

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 }

进程大杂烩_第6张图片

加入了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;
}

进程大杂烩_第7张图片
我们在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));

进程大杂烩_第8张图片

6、父进程等待子进程退出(二)

再来细说wait()函数
进程大杂烩_第9张图片

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

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;
}

进程大杂烩_第10张图片

你可能感兴趣的:(找工作,linux)