进程创建

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

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

阻塞等待和非阻塞等待

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

进程创建

ork函数

写时拷贝

进程终止

进程退出三种场景

进程常见退出方法

进程等待

进程等待的方法

wait方法

waitpid方法

获取子进程的status

阻塞等待和非阻塞等待

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像