进程创建

进程创建的最常见的两种场景:

1.命令行启动命令(程序,指令等)

2.通过程序自身fork出来子进程

ork函数

fork在前面有讲过，关于fork的用法可以去前面看看。在这里接着往下讲:

fork创建子进程是以父进程为模板的，很多数据代码继承父进程，它从存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

fork函数也是一个系统调用接口，为当前进程创建子进程，子进程返回0，父进程返回子进程pid,出错返回-1。

进程调用fork函数，内核需要做什么?

给子进程分配内存空间,并为子进程创建PCB

将父进程部分数据结构内容(还有代码和数据暂时共享)拷贝至子进程

添加子进程到系统进程列表(运行队列)当中

fork返回，开始CPU调度器调度

代码如下:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
  pid_t ret = fork();
  if (ret < 0)
  {
    perror("fork");
    return 1;
  }
  else if (ret == 0)// 子进程
  {
    printf("I am child-pid:%d, ppid:%d\n", getpid(), getppid());
    sleep(1);
  }
  else if (ret > 0)// 父进程
  {
    printf("I am parent-pid:%d, ppid:%d\n", getpid(), getppid());
    sleep(1);
  }
  sleep(1);
  return 0;
}

运行结果

返回值:子进程返回0，父进程返回子进程id,出错返回-1

为什么有两个返回值?

fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB,虚拟内存，页表，最后将当前进程设置为R状态，放置进调度列表中，此时进程已经创建成功,父子进程共享代码，fork函数的最后一个代码是返回一个值,return ret这个代码父子进程都会执行一次，所以会有两个返回值。

在返回时，将函数的返回值返回给变量,发生了写时拷贝,一个变量名但是内容是不相同的,本质父子页表映射数据到了不同的内存区域。

写时拷贝

通常情况下，父子进程共享一份代码，且数据也是共享的，当任意一方试图写入更改数据，那么者一份便要以写时拷贝的方式各自私有一份副本，写时拷贝的识别，操作等是由OS完成。

从图中可以看出,发生写时拷贝后，修改方将改变页表中对该份数据的映射关系,父子进程各自私有那一份数据，且权限由只读变成只写。

在不写入的情况下，父子进程共享代码和数据:

#include<stdio.h>
#include<unistd.h>
int main()
{
    const char *str = "hello Linux!\n";
    fork();
    while(1)
    {
        printf("pid:%d,ppid: %d,str: %s\n",getpid(),getppid(),str);
        sleep(1);
    }
    return 0;
}

运行结果

可以看到代码每次执行两次，其实是两个进程在执行。其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的。

代码共享:所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享?因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。

fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段:父进程等待客户端请求，生成子进程来处理请求。

一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

fork调用失败的原因

系统中有太多进程

实际用户的进程数超过了限制

问题分析

为什么代码是共享？

代码是不能被修改的，各自私有是很浪费空间的，大多数情况下是共享的，但是在特殊情况下，代码也是会发生写时拷贝的,也就是进程的程序替换(后面详细讲)。

2.写时拷贝的作用?

可以减少空间浪费，在双方都不对数据或代码进行修改的情况下，各自私有一根数据和代码是浪费空间的。

维护进程之间的独立性，虽然父子进程共享一份数据，但是父子中有一方对数据进行修改,那么就拷贝该份数据给修改方，改变修改方中页表对这份数据的映射关系，然后对数据进行修改，这样不管哪一方对数据进行修改都不会影响另一方，这样就做到了独立性。

3.写时拷贝是对所有数据进行拷贝嘛?

答案是否定的。如果没有修改的数据进行拷贝，那么这样还是会造成空间浪费的，没有被修改的数据还是可以共享的，我们只需要将修改的那份数据进行写时拷贝即可。

进程终止

进程退出三种场景

代码运行完成，结果正确

代码没有任何错误，且代码逻辑正确

代码运行完成，结果不正确

代码运行过程中没有任何错误，但是代码逻辑存在问题,导致结果不正确

代码运行异常终止

代码运行过程中发生了例一些异常终止的错误，如:野指针访问，除零错误等

进程常见退出方法

正常终止

1.main函数返回退出码

main函数退出的时候，return的返回值就是进程的退出码。0在函数的设计中,一般代表是正确而非0就是错误的。

echo $?

实例演示:

1. int main()
2. {
3. return 0;
4. }

运行结果

为什么main函数的return一般写成0？0在函数设计中，一般代表正确，非零代表出错。这里的return是给系统看，确认进程的执行结果是否正确，退出码可以人为的定义，也可以使用系统的错误码list，那么非零到底是什么意思?当程序运行失败的时候，我们最关心的是为什么失败?失败原因，计算机不擅长处理，擅长处理整数类型的数据,所以退出码都是整数类型的，但是我们人又擅长字符串的描述，所以就有错误码和字符串的映射；

#include<stdio.h>
#include<string.h>
int main()
{
  for(int i=0;i<200;i++)
  {
    printf("%d:%s\n",i,strerror(i));
  }
  return 0;
}

2.调用exit函数

exit:终止整个进程，任何地方调用，都会终止

return:终止函数，如果是main函数return ,代表终止进程

int main()
{
  cout << "12345";
  sleep(3);
  exit(0);// 退出进程前前会执行用户定义的清理函数，且刷新缓冲区
  return 0;
}

运行结果

调用exit函数，此时直接就讲进程终止了，并不会再去执行下面的语句了。

3.调用_exit函数

exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区,而_exit在退出时不会刷新缓冲区。

会刷新缓冲区

int main()
{
    cout<<"123";//写入缓冲区
    exit();
}

不会刷新缓冲区

1. int main()
2. {
3.     cout<<"123";//写入缓冲区
4.     _exit();
5. }

示意图:

异常终止

ctrl+C终止前台进程
ctrl+C终止前台进程
站在OS角度，如何理解进程终止?

进程终止的核心思想就是归还资源：

1、"释放"曾经为了管理进程所维护的所有的数据结构对象。

2、释放程序代码和数据占用的内存空间。

3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)

上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"

第二个释放不是代码和数据清空，而是把内存设置为无效就可以了

实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。

进程等待

进程等待的必要性:

子进程必须要比父进程先退出,否则会变成孤儿进程
父进程必须读取子进程的退出状态，回收子进程的资源。如果父进程不读取子进程退出状态,还不会是子进程资源，那么子进程将处于僵死状态，会造成内存泄漏
父进程派给子进程的任务完成的如何，得知子进程执行结果

进程等待的方法

wait方法

wait函数原型:

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);

返回值

返回值有两种，一种是等待进程的pid,另一种就是-1，等待成功返回等待进程的pid,等待失败就返回-1

参数

status是一个输出型参数,可以通过传地址获得进程退出状态,如果不想关心进程退出状态，就传NULL

实例演示

让子进程先运行5s,然后退出进程,子进程由S状态变为Z状态,父进程等待子进程,回收子进程资源后，子进程变为Z状态变为X状态,10秒回父进程退出

代码如下

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
  pid_t ret= fork();
  if (ret< 0){
    cerr << "fork error" << endl;
  }
  else if (ret== 0){
    // child
    int count = 5;
    while (count){
    printf("child[%d]:I am running... count:%d\n", getpid(), count--);
    sleep(1);
    }
    exit(1);
  }
  // parent
  printf("father begins waiting...\n");
  sleep(10);
  pid_t id = wait(NULL);// 不关心子进程退出状态
  printf("father finish waiting...\n");
  if (id > 0){ 
    printf("child success exited\n"); 
  } else{
    printf("child exit failed\n"); 
  } 
  //父进程再活5秒 
  sleep(5);
  return 0;
}

命令行监控脚本如下

1. while :; do ps axj | head -1 && ps axj | grep test | grep -v grep ; sleep 1; echo "############"; done

运行结果

子进程由S状态转变为Z状态

父进程等待子进程，回收子进程资源后，子进程变为Z状态变为X状态

waitpid方法

函数原型如下

pid_ t waitpid(pid_t pid, int *status, int options);

函数返回值

当正常返回的时候waitpid返回收集到的子进程的进程ID;
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集，则返回0；
如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；

参数

pid=-1时，可以等待任一个子进程,与wait等待

pid>0时，等待和pid相同的ID的子进程

status

是一个输出型参数，不想关心进程退出状态就传NULL

WIFEXITED(status):若为正常终止子进程返回的状态，则为真(查看进程是否是正常退出)

WEXITSTATUS（status):若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)

options

WNOHANG:若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束,则返回该子进程的ID(可以进行基于阻塞等待的轮询访问)

0:阻塞等待(等待期间父进程不执行任何操作)

实例演示

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
 int main()
 {
  pid_t id=fork();
  if(id==0)
  {
      int cnt=3;
      while(cnt)
      {
        printf("child[%d] is running:cnt is:%d\n",getpid(),cnt);
       cnt--;
        sleep(1);
      }
     //exit(0);
      exit(11);                                                                                                                                                                                                 
    }
    printf("father wait begin!\n");
   int status=0;
    pid_t ret=waitpid(id,&status,0);
    if(ret>0)
    {
      printf("father wait:%d,success,status exit code:%d.status exit signal:%d\n",ret,(status>>8)&0xFF,status&0x7F);
    }
    else{
      printf("father wait failed!\n");
    }
  }

运行结果

正常跑完，结果正确

正常跑完，结果不正确

获取子进程的status

wait和waitpid中都有一个status参数,该参数是一个输出型参数,由操作系统来填充
如果该参数给NULL,那么代表不关心子进程的退出信息

status的几种状态:(我们只研究status的低16位)

看图可以知道，低7位代表的是终止信号，第8位时core dump标志，高八位是进程退出码（只有正常退出是这个退出码才有意义）

status的0-6位和8-15位有不同的意义。我们要先读取低7位的内容，如果是0，说明进程正常退出，那就获取高8位的内容，也就是进程退出码；如果不是0，那就说明进程是异常退出，此时不需要获取高八位的内容，此时的退出码是没有意义的。

实例演示

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
  pid_t ret = fork();
  if (ret < 0){
    cerr << "fork error" << endl;
  }
  else if (ret == 0){
    // child
    int count = 5;
    while (count){
      printf("child[%d]:I am running... count:%d\n", getpid(), count--);
      sleep(1);
    }
    exit(1);
  }
  // parent
  printf("father begins waiting...\n");
  int status;
  pid_t id = wait(&status);// 从status中获取子进程退出的状态信息
  printf("father finish waiting...\n");
  if (id > 0 && (status&0x7f) == 0){
    // 正常退出
    printf("child success exited, exit code is:%d\n", (status>>8)&0xff);
  }
  else if (id > 0){
    // 异常退出
    printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
  }
  else{
    printf("father wait failed\n");
  }
  if (id > 0){ 
    printf("child success exited\n"); 
  } else{
    printf("child exit failed\n"); 
  } 
  return 0;
}

代码运行结果如下

阻塞等待和非阻塞等待

操控者：操作系统
阻塞的本质：父进程从运行队列放入到了等待队列，也就是把父进程的PCB由R状态变成S状态，这段时间不可被CPU调度器调度

等待结束的本质：父进程从等待队列放入到了运行队列，也就是把父进程的PCB由S状态变成R状态，可以由CPU调度器调度

阻塞等待：父进程一直等待子进程退出，期间不干任何事情

实例1：

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
  pid_t id = fork();
  if (id < 0){
    cerr << "fork error" << endl;
  }
  else if (id == 0){
    // child
    int count = 5;
    while (count){
      printf("child[%d]:I am running... count:%d\n", getpid(), count--);
      sleep(1);
    }
    exit(0);
  }
  // 阻塞等待
  // parent
  printf("father begins waiting...\n");
  int status;
  pid_t ret = waitpid(id, &status, 0);
  printf("father finish waiting...\n");
  if (id > 0 && WIFEXITED(status)){
    // 正常退出
    printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
  }
  else if (id > 0){
    // 异常退出
    printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
  }
  else{
    printf("father wait failed\n");
  }
}

非阻塞等待： 父进程不断检测子进程的退出状态，期间会干其他事情（基于阻塞的轮询等待）
实例2

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
  pid_t id = fork();
  if (id < 0){
    cerr << "fork error" << endl;
  }
  else if (id == 0){
    // child
    int count = 5;
    while (count){
      printf("child[%d]:I am running... count:%d\n", getpid(), count--);
      sleep(1);
    }
    exit(0);
  }
  // 基于阻塞的轮询等待
  // parent
  while (1){
    int status;
    pid_t ret = waitpid(-1, &status, WNOHANG);
    if (ret == 0){
      // 子进程还未结束
      printf("father is running...\n");
      sleep(1);
    }
    else if (ret > 0){
      // 子进程退出
      if (WIFEXITED(status)){
        // 正常退出
        printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
      }
      else{
        // 异常退出
        printf("child exited error,exit singal is:%d", status&0x7f);
      }
      break;
    }
    else{
      printf("wait child failed\n");
      break;
    }
  }
}

【Linux篇】第九篇——Linux下的进程控制（一）

进程创建

ork函数

写时拷贝

进程终止

进程退出三种场景

进程常见退出方法

进程等待

进程等待的方法

wait方法

waitpid方法

获取子进程的status

阻塞等待和非阻塞等待

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像