linux入门之进程控制（上）进程创建，进程等待-Toy模板网

这篇具有很好参考价值的文章主要介绍了linux入门之进程控制（上）进程创建，进程等待。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、进程创建

1.fork函数

2.fork函数返回值

3.写时拷贝

4.fork常规用法

5.fork调用失败原因

二、进程终止

1.进程退出场景

2.进程常见退出方法

2.1_exit函数（直接调用内核）

2.2 exit函数

2.3return退出

三、进程等待

1.进程等待必要性

2.进程等待方法

2.1 wait方法

2.2 waitpid方法

2.3获取子进程的status（整数）

3.进程阻塞等待

4.进程非阻塞等待

4.1实验1 可以采用回调的方式让父进程做其他事情

一、进程创建

1.fork函数

在Linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程，新进程为子进程，原进程为父进程。

#include<unistd.h>

pid_t fork(void);

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

进程调用fork，当控制转移到内核中的fork代码后，内核做：

分配新的内存块和内核数据结构给子进程

将父进程部分数据结构拷贝至子进程

添加子进程到系统进程列表中

fork返回，开始调度器调度

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且他们都运行到相同的地方，每个进程都可以做自己的任务。

int main( void )
{
 pid_t pid;
 printf("Before: pid is %d\n", getpid());

 if ( (pid=fork()) == -1 )
    perror("fork()"),exit(1);

 printf("After:pid is %d, fork return %d\n", getpid(), pid);
 sleep(1);
 return 0;
}


打印结果: 

Before:pid is 43676
After:pid is 43676,fork return 43677
Ater:pid is 43677,fork return 0

通过上述代码可以观察到，fork之前父进程独立执行，fork之后父子两个执行流分别执行。父子进程谁先执行完全由调度器决定

2.fork函数返回值

子进程返回0

父进程返回的是子进程的pid

3.写时拷贝

通常，父子代码共享，父子不再写入时，代码也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

linux入门之进程控制（上）进程创建，进程等待,linux,linux,服务器,c语言,c++,后端

4.fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段，例如，父进程等待客户端请求，生成子进程来处理请求（网络服务器）

一个进程要执行一个不同的程序。例如，子进程要执行exec函数

5.fork调用失败原因

系统中由太多的进程
实际用户的进程超过了限制

二、进程终止

1.进程退出场景

代码运行完毕，结果正确

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

代码异常终止

2.进程常见退出方法

正常终止（从main返回，调用exit,_exit)

此时可以通过echo $ 进程pid 查看进程退出码

异常退出

可能原因：野指针访问了某个区域导致进程异常，或者代码中/0

进程由于某些原因导致进程收到了来自os的信号（kill-9)

2.1_exit函数（直接调用内核）

#include<unistd.h>

void _exit(int status)

参数：status定义了进程的终止状态，父进程通过wait获取该值

2.2 exit函数

#include<unistd.h>

void exit(int status);

exit是C库函数，最后也会调用_exit;但是在调_exit之前，还做了其他工作:

1.执行用户通过atexit或on_exit定义的清理函数；

2.关闭所有打开的流，所有的缓存数据均被写入

linux入门之进程控制（上）进程创建，进程等待,linux,linux,服务器,c语言,c++,后端

printf是向标准输出文件中写入，因为不满足刷新策略(\n)，所以暂存在缓冲区，缓冲区是C库中一个全局的字符数组 char buffer[1000];exit结束进程之前，先刷新缓冲区，再调用内核去kill进程；_exit函数直接调用内核杀掉进程，没有刷新缓冲区，所以没有打印出来hello

2.3return退出

return是一种更常见的退出进程的方法，执行return(n)等同于执行exit(n)，因为调用main的运行时函数会将main的返回值当作exit的参数

三、进程等待

1.进程等待必要性

子进程退出，父进程如果不管不顾，就会造成“僵尸进程”，从而导致内存泄露

另外，一个进程一旦变成僵尸状态，kill-9也无法杀死

最后，父进程派给子进程的任务完成的如何，我们需要获取状态码

父进程通过进程等待的方式，回收子进程的资源，获取子进程的退出信息

2.进程等待方法

2.1 wait方法

#include<sys/types.h>

#include<sys/wait.h>

pid_t wait(int * status);

等待一个进程状态的变化（等进程死掉）

返回值：成功返回被等待进程pid,失败返回-1

参数：输出型参数，获取子进程退出状态，不关心则可以设置为NULL

#include<sys/types.h>
#include<sys/wait.h>

//创建子进程，子进程活5s,父进程先等待10s；开始运行，子进程先运行5s结束变成z状态，z状态维持5s,父进程开始回收,再过5s父进程退出
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("我是子进程，我还活着，我还有%d s, pid: %d ,ppid: %d", cnt, getpid(),getppid());
            sleep(1);
        }
        exit(0);   //子进程退出
    }
    
    
    //父进程
    sleep(10);
    pid_t ret_id = wait(NULL);
    printf("我是父进程，等待子进程成功，pid:%d,ppid:%d,ret_id:%d",getpid(),getppid(),ret_id);
    sleep(5);
    
}

打印结果：
我是子进程.... 5s
              4s
...
              1s     S状态
然后子进程10739  Z 状态 
过了5s 父进程10737开始回收，得到ret_id = 10739

父进程在wait的时候，如果子进程没退出，父进程此时在等待子进程。

2.2 waitpid方法

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

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程id

如果涉及了选项WNOHANG,而调用waitpid发现没有已退出的子进程可收集，则返回0

如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在

参数：

        pid:

        pid = -1 等待任意一个进程，与wait等效

        pid > 0 等待指定的进程（进程号）

        status: 输出型参数信号+退出码

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

        WEXITSTATUS（status):若wifexited非0，提取子进程退出码（查看进程的退出码）

        options:

        WNOHANG:若pid指定的子进程没有结束，则waitpid()函数返回0，不予等待。若正常结束，则返回该子进程的id

如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程的退出信息
如果任意时刻调用wait/waitpid,子进程存在且正常运行，则可能导致进程阻塞
如果不存在该子进程，则立即出错返回

2.3获取子进程的status（整数）

linux中提供了64种信号，由编号和名称，名称（SIGKILL）--宏编号宏对应的值（9），没有0号信号。所以信号也是一个数字。

int 类型有32bit 0000 0000 0000 0000 0000 0000 0000 0000 0000 看成位图结构

status只关心后16位

正常终止：获取高15 - 8位(status >>8)&0xFF---> 表示退出状态，就是exit(status) 后7位均为0,没有收到退出信号。这里的status如果是0，就是正常终止，并且运行结果正确，如果非0，就是正常终止，但是运行结果错误

异常退出：被信号所杀，高15-8未没有使用，获取低7位（status && 0x7F)-->终止信号。如果终止信号非0.就是异常退出，此时不必关注进程退出码

int main()
{
    pid_t id = fork();
    if(id ==0)
    {
        int cnt = 5;
        while(cnt)
        {
            printf("");
            sleep(1);
        }
    
            exit(107);  //  使用方法： if(异常) exit(非 0）
   }
    
    int status = 0;
    pid_t ret_id = waitpid(id,&status,0);
    //printf("child exit status : %d",ret_id);  
    //ret_id = 27392  status不是将一个整数作为整体使用 
    printf("child exit code :%d, child signal :%d\n",(status>>8)&0xFF, status & 0x7F);
}
    

child exit code: 107;
child signal : 0

正常退出 结果不正确

父进程是如何获取子进程的退出信息？

父进程的pcb中有两个int exit_code,exit_signal，这两个数是子进程返回码写到exit_code中，如果出现异常，异常数写到exit_signal中;父进程通过wait/waitpid系统调用接口，找到这个pcb,查找到这两个数，传到status中，用户就拿到了status。

3.进程阻塞等待

在子进程没有退出的时候，父进程只能一直在调用waitpid进行等待，这种就是阻塞等待。父进程此时一定不是运行状态，所以不在运行队列，此时父进程在阻塞队列中。子进程的pcb中有一个指针 tast struct *parent,指向父进程的pcb，当子进程退出，parent指针找到父进程，把父进程放进运行队列中，获取到waitpid的值

4.进程非阻塞等待

在子进程没退出时，不想在waitpid卡住，做父进程的任务。进行多次检测，就是非阻塞轮询。

WNOHANG: 如果为 0 表示阻塞如果WNOHANG 表示非阻塞，下列代码为非阻塞轮询

//父进程 非阻塞轮询等待

while(1)
{
    int status = 0;
    pid_t ret_id = waitpid(id,&status,WNOHANG);   //夯住了
    if(ret_id <0) 
    {
        printf("waitpid error");
    }
    
    else if(ret_id == 0)
    {
        //子进程还没退出，父进程做其他事
        sleep(1);    //这个时间充当做任务的时间
        continue;  // 继续等待
    }
    
    else
    {
        //等待成功
        printf("等待成功");
        break;
    }
    
}

4.1实验1 可以采用回调的方式让父进程做其他事情

代码如下：文章来源地址https://www.toymoban.com/news/detail-525164.html

#define TASK_NUM 10

//预设一批任务

void sync_disk()
{
    printf("刷新数据\n");
}

void sync_log()
{
    printf("同步日志\n");
}

void net_send()
{
    printf("网络发送\n");
}


//要保存任务相关的

typedef void(*fun_t)();  // 定义一个名字叫fun_t的函数指针
fun_t other_task[TASK_NUM] = {NULL};  //定义一个函数指针数组


int LoadTask(func_t func)
{
    int i = 0;
    for(; i<TASK_NUM; i++)   
    {
        if(other_task[i] == NULL)   //判断这个位置是不是空的
            break;
    }

    if(i == TASK_NUM)   //如果遍历完都没找到有空的位置 说明放满了，没法继续放了
        return -1; //装载满了
    else
        other_task[i] = func;   //否则放在空的位置
    
    return 0;   //退出
}

 void InitTask()
 {
      for(int i = 0; i<TASK_NUM;i++)
    {
        other_task[i] = NULL;
    }

    LoadTask(sysc_disk);
    LoadTask(sync_log);   //第二次加载，i=0的位置已经放了，i++,再break放入
    LoadTask(net_send);
}


void RunTask()
{
    for(int i = 0; i<TASK_NUM; i++)
    {
        if(other_task[i] == NULL  
            continue;
        other_task[i]()  //调用这个任务
    }
}


int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        int cnt = 50;
        while(cnt)
        {
            printf("我是子进程，我还有%d S ,pid:%d,ppid:%d",cnt--,getpid(),getppid());
            sleep(1);
        }

        exit(111);
    }

     InitTask();   //初始化加载完毕
    //父进程
    while(1)
    {
         int status = 0;
         pid_t id = waitpid(id,&status, WNOHANG); //夯住了
         if(ret_id < 0)
        {
            RunTask();
            sleep(1);
            continue;
        }
        
        else
        {
            if(WIFEXITED(status))
            {
                printf("wait success,child exit code :%d\n",WEXITSTATUS(status));
            }

            else
            {
                printf("wait success,child exit signal:%d\n",status &0x7F);
            }

            break;
        }
    }
}

到了这里，关于linux入门之进程控制（上）进程创建，进程等待的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！