Linux：进程创建-等待-退出

Linux学习目录

---

1、进程的创建

1.1：fork函数

pid_t fork(void)
返回值：父进程返回子进程id，子进程返回0，出错返回-1

当进程调用fork时，内核中的fork都做下面的事情
>

• 分配新的内存块和内核数据给子进程
• 将父进程的部分数据结构拷贝到子进程中
• 添加子进程到系统进程列表中
• fork返回，开始调度器调度

eg:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
    pid_t pid;

    printf("before pid = %d\n",getpid());
    pid = fork();
    if(pid < 0)
    {
        perror("fork error\n");
        return 1;
    }
    else if(pid == 0)
    {
        printf("childpid = %d,pid return %d\n",getpid(),pid);
        sleep(10);
    }
    else//parent
    {

        printf("parentpid = %d,pid return %d\n",getpid(),pid);
        sleep(3);
        exit(0);
    }
    return 0;
}

从打印的值可以看出，before打印一行，after打印两行，父进程pid=21522打印出before，但子进程pid=21523没有打印出beofre

所以fork之前父进程独立运行，fork之后，父子进程分别执行，但是谁先执行完全由进程调度器决定。
fork的一般用法：

• 一个父进程希望复制自己，使父子进程同时执行不同的代码段
• 一个进程要执行一个不同的程序
  看下面代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int g = 10;

int main()
{
    pid_t pid;

    pid = fork();
    if(pid < 0)
    {
        perror("fork error\n");
        return 1;
    }
    else if(pid == 0)
    {
        sleep(2);
        g = 20;
        printf("child g =  %d\n",g);
        exit(0);
    }
    else//parent
    {

        printf("parent g =  %d\n",g);
    }
    return 0;
}

从输出结果可以看出fork子进程具有和父进程独立的地址空间
fork的注意点：

• 1.fork之后，父子进程交替运行
• 2.如果父进程死亡，子进程还活着，叫孤儿进程。（孤儿进程托管给1号进程，1号进程也叫孤儿院）
• 3.如果父进程活着，子进程死亡，子进程死亡就会成为僵尸进程，僵尸进程会占用少量系统图资源，

1.2：vfork函数

pid_t vfork(void);

• vfork也是用来创建进程子进程的，但是vfork创建的子进程和父进程共享一块地址空间，而fork子进程具有独立的地址空间
• vfork保证子进程先运行，在它调用exec或exit之后父进程才可能被调度运行,而fork的父子进程那个先运行完全由调取器决定。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int g = 10;

int main()
{
    pid_t pid;
    pid = vfork();
    if(pid < 0)
    {
        perror("fork error\n");
        return 1;
    }
    else if(pid == 0)
    {
        sleep(2);
        g = 20;
        printf("child g =  %d\n",g);
        exit(0);
    }
    else//parent
    {

        printf("parent g =  %d\n",g);
    }
    return 0;
}

从输出结果看出，vfork父子进程具有相同的地址空间
vfork特点：

• 1.父进程阻塞，直到子程序运行完毕
• 2.就算写时，也不拷贝
• 3.必须使用exit或者exec才不会出现段错误
• 4.每个系统对vfork的实现或多或少都有问题，所以尽量不要使用

2、进程的等待

• 2.1：僵尸进程
  进程等待就是为了处理僵尸进程，所以先了解一下僵尸进程

  僵尸进程：
  子进程结束了，但是他的父进程没有等待(调用wait / waitpid)， 那么他将变成一个僵尸进程。 但是如果该进程的父进程已经先结束了，那么该进程就不会变成僵尸进程， 因为每个进程结束的时候，系统都会扫描当前系统中所运行的所有进程， 看有没有哪个进程是刚刚结束的这个进程的子进程，如果是的话，就由Init 来接管他，成为他的父进程

• 2.2：僵尸进程产生的原因：
  如果子进程先于父进程退出， 同时父进程又没有调用wait/waitpid，则该子进程将成为僵尸进程

int main(void)
{
    pid_t pid = fork();
    if( pid < 0   ) 
    {     
        perror("fork error\n");
    } else if( pid ==0 )
    {    in child process
        printf(" child process\n ");
    }
    else
    { //  parent process
        printf("parent process\n");
        sleep(100);
    }
    return 0;
}

父进程睡眠100s后才退出，所以子进程先退出，子进程变为僵尸进程

Z+代表僵尸进程

• 2.3：僵尸进程的危害
  僵尸进程会占用少量的系统资源，如果产生大量的僵尸进程，就会很消耗系统资源，产生内存泄漏，可能导致因为没有可用的进程号而导致系统不能产生新的进程.

• 2.4：进程等待

pid_t wait(int *status);

• 1.0：父进程阻塞，直到有子进程退出才返回
• 2.0：status输出型参数，得到子进程的退出信息。不关⼼则可以设置成为NULL，如果参数status不为空，则进程终止状态被保存于其中；status参数会得到子进程是如何死亡，一些特定的宏可以得到子进程的返回信息。
• :3.0返回值：被回收的子进程ID，出错了，返回-1

特定的宏：
WIFEXITED(status)//如果正常退出，返回真
WEXITSTATUS(status)//如果正常退出，得到退出码
WIFSIGNALED(status)//如果被信号打断，返回真
WTERMSIG(status)//如果信号被打断，返回打断信号的值

eg：

#include<stdio.h>
#include<unistd.h>
#incldue<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>

int main(void)
{
    pid_t pid = fork();

    if(pid == 0)
    {
        printf("child pid = %d,return pid = %d\n",getpid(),pid);
        sleep(5);
        exit(0);

    }
    else
    {

        int status;
        wait(&status);
        printf("parent pid=%d,return pid = %d\n",getpid(),pid);
        if(WIFEXITED(status))
        {
            printf("exit code = %d\n",WEXITSTATUS(status));
        }
        if(WIFSIGNALED(status))
        {
            printf("sign no = %d\n",WTERMSIG(status));
        }
    }
}

使用特定的宏返回子进程的退出状态和信息。

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

• pid解析
  
  • pid > 0:等待进程id等于pid的子进程，不管是否有其他进程结束，只有指定进程没有结束，waitpid就会一直等下去。
  • pid = 0:调用者进程所在进程组的任何一个子进程死亡，它都会回收
  • pid = -1 等待任何一个子进程死亡（和wiait一样）
  • pid < -1:等待|pid|进程组的任何一个子进程死亡并回收（pid = -5，那么pid = 5的进程组中任何一个子进程死亡它都会回收）
• option解析
  
  • 当options参数为0时，与wait功能相同，仍是阻塞式等待。
  • WNOHANG：如果pid指定的子进程并不是立即结束，则waitpid不阻塞，即此时以非阻塞方式等待子进程，并且返回0。若正常结束，则返回该⼦进程的ID。
• 返回值：
  
  • 正常返回时，waitpid返回子进程id
  • 设置WHOHANG时，调用waitpid发现没有已退出子进程，则返回0
  • 如果调用出错，则返回-1，

eg:

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>

int main(void)
{
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error\n");
        return 1;
    }
    else if(pid == 0)
    {
        printf("child pid = %d,return pid = %d\n",getpid(),pid);
        sleep(5);
        exit(0);

    }
    else
    {

        int status = 0;
        pid_t ret = waitpid(-1,&status,0);//阻塞等待，等待5s子进程死亡，回收
        printf("parent pid=%d,return pid = %d\n",getpid(),pid);
        printf("wait 5s\n");
        if(WIFEXITED(status) && ret == pid)
        {
            printf("wait 5s success,child return code is : %d\n",WEXITSTATUS(status));
        }
        if(WIFSIGNALED(status))
        {
            printf("sign no = %d\n",WTERMSIG(status));
        }
    }
    return 0;
}

• 2.4：进程退出
  
  • 正常退出：
    
    • main函数退出
    • exit退出
  • 异常退出：
    
    • ctul+c退出,信号终止
    • about函数退出（类似于exit，但这个不是正常的退出）
    • kill pid 杀死进程
• exit函数退出

void exit(int status);
exit是c库函数，status为0代表正常退出，非0是非正常退出

exit函数执行那些操作呢？

• 执行用户通过atexit（终止处理程序）或on_exit定义的清理函数
• 关闭所有打开流，所有缓存数据均被写入
• 调用_exit函数

void _exit(int status);
参数status定义进程的终止状态，父进程通过wait获取该值
_exit是系统调用，并且_exit(0),没有刷新缓冲区的功能，需要手动加上

fflush(stdout);//不加这句话不会刷新缓冲区
_exit(0);

• return退出：
  return是常见的退出进程方式，执行return n等同于执行exit(n),就像main函数中return(0)和exit(0)一样。但是他们还是有区别的。
  
  • exit用于结束正在运行的整个程序,它将参数返回给操作系统，把控制权交给系统
  • return是结束当前函数，返回函数值，把控制权交给调用函数
  • exit是系统调用级别，代表一个进程的结束，而return是语言级别的，表示调用堆栈的返回