Linux非阻塞等待示例

非阻塞等待的意义：

非阻塞等待在多进程编程中的意义主要体现在提高系统的响应性、实现异步任务执行、动态任务管理和多任务协同工作等方面。它允许父进程在等待子进程退出的同时，继续执行其他任务，从而提高系统的并发性和效率，增加系统的灵活性和可扩展性。

简单的多进程编程示例

#include 
#include 
#include 
#include 
#include 

#define TASK_NUM 5

typedef void (*task_t)();


void download()
{
    printf("this is a download task is rnning!（正在执行下载任务）\n");
}
void printLog()
{
    printf("this is a write log task is rnning!（正在执行日志任务）\n");
}
void show()
{
    printf("this is a show info task is rnning!（正在执行显示信息任务）\n");
}



void initTasks(task_t tasks[], int num)
{
    for(int i = 0; i < num; i++) tasks[i] = NULL;
}

int addTask(task_t tasks[], task_t t)
{
    int i = 0;
    for(; i < TASK_NUM; i++)
    {
        if(tasks[i] == NULL)
        {
            tasks[i] = t;
            return 1;
        }
    }
    return 0;
}

void executeTask(task_t tasks[], int num)
{
    for(int i = 0; i < num; i++)
    {
        if(tasks[i]) tasks[i]();
    }
}

void worker(int cnt)
{
    printf("I am child, pid: %d, cnt: %d\n", getpid(), cnt);
}

int main()
{
    task_t tasks[TASK_NUM];
    initTasks(tasks, TASK_NUM);
    addTask(tasks, download);
    addTask(tasks, printLog);
    addTask(tasks, show);

    pid_t id = fork();
    if(id == 0){
        // child
        int cnt = 10;
        while(cnt)
        {
            worker(cnt);
            sleep(2);
            cnt--;
        }

        exit(0);
    }

    while(1)
    {
        //father
        int status = 0;
        // 非阻塞等待，可以让等待方在返回的时候，顺便做做自己的事情
        pid_t rid = waitpid(id, &status, WNOHANG);
        if(rid > 0)
        {
            // wait success, child quit now;
            printf("child quit success（孩子退出成功）, exit code: %d, exit signal: %d\n", (status>>8)&0xFF, status&0x7F);
            break;
        }
        else if(rid == 0)
        {
            printf("##################################################\n");
            // wait success, but child not quit
            printf("child is alive, wait again, father do other thing（孩子还活着，再次等待，父亲做其他事情）....\n");
            // 该函数内部，其实是回调式执行任务
            executeTask(tasks, TASK_NUM); // 也可以在内部进行自己移除&&新增对应的任务
            printf("##################################################\n");
        }
        else{
            // wait failed, child unknow
            printf("wait failed!\n");
            break;
        }

        sleep(1);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

运行结果：

…

代码解释

这段代码主要使用了 fork() 和 waitpid() 系统调用来创建和管理子进程。下面是代码的详细解释：

包含了必要的头文件：

：标准输入输出库，用于输入输出操作。
：标准库，提供了一些通用工具函数，如内存分配和进程控制。
：Unix 标准库，提供了对 POSIX 操作系统 API 的访问。
：包含了进程标识符 pid_t 的定义。
：包含了等待进程结束的函数 waitpid() 的定义。

定义了一个常量 TASK_NUM，表示任务的数量。
typedef了一个函数指针类型 task_t，用于表示任务函数的类型。

定义了三个具体的任务函数 download()、printLog() 和 show()，用于演示任务的执行过程。这些函数只是简单地打印一些信息。

• 定义了一个辅助函数 initTasks()，用于初始化任务数组。该函数会将任务数组中的所有元素设置为 NULL。
• 定义了一个辅助函数 addTask()，用于将任务添加到任务数组中。该函数会遍历任务数组，找到第一个为 NULL 的位置，并将任务函数指针存储在该位置。如果找不到空闲位置，则返回 0；否则返回 1。
• 定义了一个辅助函数 executeTask()，用于执行任务数组中的任务。该函数会遍历任务数组，对于非空的任务函数指针，调用对应的任务函数。

• 定义了一个辅助函数 worker()，用于在子进程中执行具体的工作。该函数会打印进程的 ID（使用 getpid() 函数）和计数值。

在 main() 函数中：

1. 声明了一个任务数组 tasks[TASK_NUM]，并通过调用 initTasks() 初始化该数组。
2. 调用 addTask() 函数将三个任务函数 download()、printLog() 和 show() 添加到任务数组中。
3. 调用 fork() 创建一个子进程。如果返回值为 0，则表示当前代码在子进程中执行，否则表示在父进程中执行。
4. 在子进程中，通过一个循环调用 worker() 函数执行具体的工作。每次循环都会打印进程的 ID 和计数值，并使用 sleep(2) 函数暂停 2 秒，然后将计数值减 1，直到计数值为 0。
5. 在子进程的循环结束后，调用 exit(0) 终止子进程。
6. 在父进程中，通过一个无限循环调用 waitpid() 函数来等待子进程的退出。waitpid() 函数用于等待指定的子进程结束，并获取子进程的退出状态。
7. 使用 WNOHANG 选项，使得 waitpid() 在没有子进程退出时立即返回。这样可以让父进程在等待期间执行其他任务。
8. **如果 waitpid() 返回值大于 0，则表示成功等待到一个子进程退出。**此时打印子进程的退出状态信息，并终止父进程的循环。
9. 如果 waitpid() 返回值等于 0，则表示当前没有子进程退出，继续执行父进程的其他任务。在这里，调用 executeTask() 函数执行任务数组中的任务，并打印一些信息。
10. 如果 waitpid() 返回值小于 0，则表示等待失败，打印错误信息，并终止父进程的循环。
11. 在父进程的循环中，使用 sleep(1) 函数暂停 1秒，以降低循环的频率。

总体来说，这段代码创建了一个子进程，并在父进程中等待子进程的退出。在等待子进程退出的过程中，父进程会执行一些其他任务，并定期执行任务数组中的任务函数。子进程通过循环执行具体的工作，并在完成后退出。在子进程退出后，父进程打印子进程的退出状态信息，并终止循环，结束程序的执行。