Linux系统编程-进程

概念

程序

程序是包含一系列信息的文件，这些信息描述了如何在运行时创建一个进程：

  • 二进制格式标识：每个程序文件都包含用于描述可执行文件格式的元信息。内核利用此信息来解释文件中的其他信息。（ELF可执行连接格式）
  • 机器语言指令：对程序算法进行编码。
  • 程序入口地址：标识程序开始执行时的起始指令位置。
  • 数据：程序文件包含的变量初始值和程序使用的字面量值（比如字符串）。
  • 符号表及重定位表：描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试和运行时的符号解析（动态链接）。
  • 共享库和动态链接信息：程序文件所包含的一些字段，列出了程序运行时需要使用的共享库，以及加载共享库的动态连接器的路径名。
  • 其他信息：程序文件还包含许多其他信息，用以描述如何创建进程。

进程

进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。

从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

单道多道程序设计

单道程序，即在计算机内存中只允许一个的程序运行。

  • 对于一个单 CPU 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU 上运行的程序只有一个。

    多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态，这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了提高 CPU 的利用率。

  • 在多道程序设计模型中，多个进程轮流使用 CPU。而当下常见 CPU 为纳秒级，1秒可以执行大约10 亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。

并行和并发

  • 并行(parallel)：同一时刻，多条指令在多个处理器上同时执行。
  • 并发(concurrency)：同一时刻，只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果。但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

进程控制块（PCB）

为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分配一个PCB(Processing Control Block)进程控制块，维护进程相关的信息，Linux 内核的进程控制块是task_struct 结构体。

进程的状态

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。

状态转换

进程的状态转换

  • 新建态：进程刚被创建时的状态，尚未进入就绪队列。
  • 就绪态：进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列。
  • 运行态：进程占有处理器正在运行。
  • 阻塞态：又称为等待(wait)态或睡眠(sleep)态，指进程不具备运行条件，正在等待某个事件的完成。
  • 终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后，一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

进程相关指令

查看进程

1
2
3
4
5
ps aux / ajx
# a：显示终端上的所有进程，包括其他用户的进程
# u：显示进程的详细信息
# x：显示没有控制终端的进程
# j：列出与作业控制相关的信息

实时显示进程动态

1
2
3
4
5
6
7
top
# 在 top 命令执行后，可以按以下按键，对显示的结果进行排序：
# M 根据内存使用量排序
# P 根据 CPU 占有率排序
# T 根据进程运行时间长短排序
# U 根据用户名来筛选进程
# K 输入指定的 PID 杀死进程

杀死进程

1
2
3
4
5
kill [-signal] pid
kill –l # 列出所有信号
kill –SIGKILL # 进程ID
kill -9 # 进程ID
killall name # 根据进程名杀死进程

进程号相关函数

  • 每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围：0～32767。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。
  • 任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。
  • 进程组是一个或多个进程的集合。它们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当做当前的进程组号。
    1
    2
    3
    4
    // 进程号和进程组相关函数
    pid_t getpid(void);
    pid_t getppid(void);
    pid_t getpgid(pid_t pid);

进程创建

系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
/*
    返回值：
        成功：子进程中返回 0，父进程中返回子进程 ID
        失败：返回 -1
    
    父进程：pid > 0
    子进程：pid == 0
    
    失败的两个主要原因：
        当前系统的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN
        系统内存不足，这时 errno 的值被设置为 ENOMEM
*/

进程虚拟地址空间

进程虚拟地址空间

实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。

  • 写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只有在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享（share-on-read）。
  • 注意：fork之后父子进程共享文件，fork产生的子进程与父进程相同的文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。

示例

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
/*
    #include <sys/types.h>
    #include <unistd.h>

    pid_t fork(void);
        函数的作用：用于创建子进程。
        返回值：
            fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。
            在父进程中返回创建的子进程的ID,
            在子进程中返回0
            如何区分父进程和子进程：通过fork的返回值。
            在父进程中返回-1，表示创建子进程失败，并且设置errno

    父子进程之间的关系：
    区别：
        1.fork()函数的返回值不同
            父进程中: >0, 返回的子进程的ID
            子进程中: == 0
        2.pcb中的一些数据
            当前的进程的id: pid
            当前的进程的父进程的id: ppid
            信号集
    
    父子进程对变量是不是共享的？
        - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
        - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。     
*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int num = 10;

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {
        // printf("pid : %d\n", pid);
        // 如果大于0，返回的是创建的子进程的进程号，当前是父进程
        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

        printf("parent num : %d\n", num);
        num += 10;
        printf("parent num += 10 : %d\n", num);
    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
        printf("child num : %d\n", num);
        num += 100;
        printf("child num += 100 : %d\n", num);
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
        sleep(1);
    }

    return 0;
}

/*
    注意：fork之后父子进程共享文件，fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。
*/

进程控制

进程退出

1
2
3
4
#include <stdlib.h>
void exit(int status); // 会刷新IO缓冲区
#include <unistd.h>
void _exit(int status); // 不会刷新

示例

  • exit.c
    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
    /*
        #include <stdlib.h>
        void exit(int status);

        #include <unistd.h>
        void _exit(int status);

        status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>

    int main() {

        printf("hello\n");
        printf("world");

        // exit(0);
        _exit(0);
        
        return 0;
    }

    /*
        exit(0):
            hello
            world
        _exit(0):
            hello
    */

孤儿进程

父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（OrphanProcess）。

  • 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地wait() 它的已经退出的子进程。这样，当一个孤儿进程结束了其生命周期的时候，init 进程就会处理它的一切善后工作。因此，孤儿进程并不会有什么危害。

示例

  • orphan.c
    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
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>

    int main() {

        // 创建子进程
        pid_t pid = fork();

        // 判断是父进程还是子进程
        if(pid > 0) {
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
        } else if(pid == 0) {
            sleep(20);
            // 当前是子进程
            printf("i am child process, pid : %d, ppid : %d\n", getpid(), getppid());
        }

        // for循环
        // for(int i = 0; i < 3; i++) {
        //     printf("i : %d , pid : %d\n", i , getpid());
        // }

        return 0;
    }
    孤儿进程

僵尸进程

每个进程结束之后， 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。

僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait() 或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用。但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

示例

  • zombie.c
    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
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>

    int main() {

        // 创建子进程
        pid_t pid = fork();

        // 判断是父进程还是子进程
        if(pid > 0) {
            while(1) {
                printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
                sleep(1);
            }
        } else if(pid == 0) {
            // 当前是子进程
            printf("i am child process, pid : %d, ppid : %d\n", getpid(), getppid());
        }

        // for循环
        for(int i = 0; i < 3; i++) {
            printf("i : %d , pid : %d\n", i , getpid());
        }

        return 0;
    }

进程回收

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息（包括进程号、退出状态、运行时间等）。

  • 父进程可以通过调用 wait() 或 waitpid() 得到它的退出状态同时彻底清除掉这个进程。wait() 和waitpid() 函数的功能一样，区别在于：wait() 函数会阻塞，waitpid() 可以设置不阻塞，还可以指定等待哪个子进程结束。
  • 注意：一次 wait() 或 waitpid() 调用只能清理一个子进程，清理多个子进程应使用循环。

示例

  • wait.c
    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
    /*
        #include <sys/types.h>
        #include <sys/wait.h>
        pid_t wait(int *wstatus);
            功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收子进程的资源。
            参数：int *wstatus
                进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
            返回值：
                - 成功：返回被回收的子进程的id
                - 失败：-1 (所有的子进程都结束，调用函数失败)

        调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
        如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.
    */
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>

    int main() {

        // 有一个父进程，创建5个子进程（兄弟）
        pid_t pid;

        // 创建5个子进程
        for(int i = 0; i < 5; i++) {
            pid = fork();
            if(pid == 0) {
                break;
            }
        }

        if(pid > 0) {
            // 父进程
            while(1) {
                printf("parent, pid = %d\n", getpid());
                // int ret = wait(NULL);
                int st;
                int ret = wait(&st);
                
                if(ret == -1) {
                    break;
                }
                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }
                printf("child die, pid = %d\n", ret);
                sleep(1);
            }
        } else if (pid == 0) {
            // 子进程
             while(1) {
                printf("child, pid = %d\n",getpid());    
                sleep(1);       
            }

            exit(0);
        }

        return 0; // exit(0)
    }
  • waitpid.c
    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
    /*
        #include <sys/types.h>
        #include <sys/wait.h>
        pid_t waitpid(pid_t pid, int *wstatus, int options);
            功能：回收指定进程号的子进程，可以设置是否阻塞。
            参数：
                - pid:
                    pid > 0 : 某个子进程的pid
                    pid = 0 : 回收当前进程组的所有子进程    
                    pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
                    pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
                - options：设置阻塞或者非阻塞
                    0 : 阻塞
                    WNOHANG : 非阻塞
                - 返回值：
                    > 0 : 返回子进程的id
                    = 0 : options=WNOHANG, 表示还有子进程或者
                    = -1 ：错误，或者没有子进程了
    */
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>

    int main() {

        // 有一个父进程，创建5个子进程（兄弟）
        pid_t pid;

        // 创建5个子进程
        for(int i = 0; i < 5; i++) {
            pid = fork();
            if(pid == 0) {
                break;
            }
        }

        if(pid > 0) {
            // 父进程
            while(1) {
                printf("parent, pid = %d\n", getpid());
                sleep(1);

                int st;
                // int ret = waitpid(-1, &st, 0);
                int ret = waitpid(-1, &st, WNOHANG);

                if(ret == -1) {
                    break;
                } else if(ret == 0) {
                    // 说明还有子进程存在
                    continue;
                } else if(ret > 0) {
                    if(WIFEXITED(st)) {
                        // 是不是正常退出
                        printf("退出的状态码：%d\n", WEXITSTATUS(st));
                    }
                    if(WIFSIGNALED(st)) {
                        // 是不是异常终止
                        printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                    }

                    printf("child die, pid = %d\n", ret);
                }
            }
        } else if (pid == 0) {
            // 子进程
            while(1) {
                printf("child, pid = %d\n",getpid());    
                sleep(1);       
            }
            exit(0);
        }

        return 0; 
    }

进程间通信

介绍

  • 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
  • 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( IPC, Inter Processes Communication )。

目的

  • 数据传输：一个进程需要将它的数据发送给另一个进程。
  • 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
  • 资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。
  • 进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

Linux 进程间通信的方式

匿名管道（管道）

管道也叫无名（匿名）管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。

特点

管道其实是一个在内核内存中维护的缓冲区，这个缓冲区的存储能力是有限的，不同的操作系统大小不一定相同。管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。

一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。

在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。

匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

使用

1
2
3
4
5
6
7
8
// 创建匿名管道
#include <unistd.h>
int pipe(int pipefd[2]);
// 查看管道缓冲大小命令
ulimit –a
// 查看管道缓冲大小函数
#include <unistd.h>
long fpathconf(int fd, int name);

示例

  • pipe.c
    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
    /*
        #include <unistd.h>
        int pipe(int pipefd[2]);
            功能：创建一个匿名管道，用来进程间通信。
            参数：int pipefd[2] 这个数组是一个传出参数。
                pipefd[0] 对应的是管道的读端
                pipefd[1] 对应的是管道的写端
            返回值：
                成功 0
                失败 -1

        管道默认是阻塞的：如果管道中没有数据，read阻塞；如果管道满了，write阻塞。
        注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
    */

    // 子进程发送数据给父进程，父进程读取到数据输出
    #include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    int main() {

        // 在fork之前创建管道
        int pipefd[2];
        int ret = pipe(pipefd);

        if(ret == -1) {
            perror("pipe");
            exit(0);
        }

        // 创建子进程
        pid_t pid = fork();
        if(pid > 0) {
            // 父进程
            printf("i am parent process, pid : %d\n", getpid());
            // 关闭写端
            close(pipefd[1]);
            
            char buf[1024] = {0};
            while(1) {
                // 从管道的读取端读取数据
                int len = read(pipefd[0], buf, sizeof(buf));
                printf("parent recv : %s, pid : %d\n", buf, getpid());
                
                // 向管道中写入数据
                //char * str = "hello,i am parent";
                //write(pipefd[1], str, strlen(str));
                sleep(1);
            }
        } else if(pid == 0) {
            // 子进程
            printf("i am child process, pid : %d\n", getpid());
            // 关闭读端
            close(pipefd[0]);

            char buf[1024] = {0};
            while(1) {
                // 向管道中写入数据
                char * str = "hello,i am child";
                write(pipefd[1], str, strlen(str));
                sleep(1);

                // int len = read(pipefd[0], buf, sizeof(buf));
                // printf("child recv : %s, pid : %d\n", buf, getpid());
                // bzero(buf, 1024);
            }
        }

        return 0;
    }
  • fpathconf.c
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    int main() {

        int pipefd[2];

        int ret = pipe(pipefd);

        // 获取管道的大小
        long size = fpathconf(pipefd[0], _PC_PIPE_BUF);

        printf("pipe size : %ld\n", size);

        return 0;
    }

有名管道（命名管道）

匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件。

有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的。这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信。因此，通过 FIFO 不相关的进程也能交换数据。 一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。与管道一样，FIFO 也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO 的名称也由此而来：先入先出。

有名管道（FIFO)和匿名管道（pipe）有一些特点是相同的，不一样的地方在于：（1）FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在内存中。（2）当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便之后使用。（3）FIFO 有名字，不相关的进程可以通过打开有名管道进行通信。

使用

1
2
# 通过命令创建有名管道
mkfifo 名字
1
2
3
4
// 通过函数创建有名管道
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

一旦使用 mkfifo 创建了一个 FIFO，就可以使用 open() 打开它，常见的文件I/O 函数都可用于 FIFO。如：close()、read()、write()、unlink() 等。 FIFO 严格遵循先进先出（First in First out），对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如 lseek() 等文件定位操作。

示例

  • mkfifo.c
    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
    /*
        创建fifo文件
        1.通过命令：mkfifo 名字
        2.通过函数：int mkfifo(const char *pathname, mode_t mode);

        #include <sys/types.h>
        #include <sys/stat.h>
        int mkfifo(const char *pathname, mode_t mode);
            参数：
                - pathname: 管道名称的路径
                - mode: 文件的权限 和 open 的 mode 是一样的
                        是一个八进制的数
            返回值：
                成功返回0
                失败返回-1，并设置错误号
    */
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>

    int main() {

        // 判断文件是否存在
        int ret = access("fifo1", F_OK);

        if(ret == -1) {
            printf("管道不存在，创建管道\n");
            
            ret = mkfifo("fifo1", 0664);

            if(ret == -1) {
                perror("mkfifo");
                exit(0);
            }
        }

        return 0;
    }
  • read.c
    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
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>

    // 从管道中读取数据
    int main() {

        // 1.打开管道文件
        int fd = open("test", O_RDONLY);
        
        if(fd == -1) {
            perror("open");
            exit(0);
        }

        // 读数据
        while(1) {
            char buf[1024] = {0};
            int len = read(fd, buf, sizeof(buf));
            if(len == 0) {
                printf("写端断开连接了...\n");
                break;
            }
            printf("recv buf : %s\n", buf);
        }

        close(fd);

        return 0;
    }
  • write.c
    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
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <string.h>

    // 向管道中写数据
    /*
        有名管道的注意事项：
            1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
            2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道

        读管道：
            管道中有数据，read返回实际读到的字节数
            管道中无数据：
                管道写端被全部关闭，read返回0，（相当于读到文件末尾）
                写端没有全部被关闭，read阻塞等待
        
        写管道：
            管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
            管道读端没有全部关闭：
                管道已经满了，write会阻塞
                管道没有满，write将数据写入，并返回实际写入的字节数。
    */
    int main() {

        // 1.判断文件是否存在
        int ret = access("test", F_OK);

        if(ret == -1) {
            printf("管道不存在，创建管道\n");
            
            // 2.创建管道文件
            ret = mkfifo("test", 0664);

            if(ret == -1) {
                perror("mkfifo");
                exit(0);
            }
        }

        // 3.以只写的方式打开管道
        int fd = open("test", O_WRONLY);
        
        if(fd == -1) {
            perror("open");
            exit(0);
        }

        // 写数据
        for(int i = 0; i < 100; i++) {
            char buf[1024];
            sprintf(buf, "hello, %d\n", i);
            printf("write data : %s\n", buf);
            write(fd, buf, strlen(buf));
            sleep(1);
        }

        close(fd);

        return 0;
    }

内存映射

内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。

使用

1
2
3
#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);

共享内存

共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于一个共享内存段会成为一个进程用户空间的一部分，因此这种 IPC 机制无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其他所有共享同一个段的进程可用。

与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存，接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种 IPC 技术的速度更快。

使用

1
2
3
4
5
6
7
8
9
// 调用 shmget() 创建一个新共享内存段或取得一个既有共享内存段的标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的共享内存标识符。
int shmget(key_t key, size_t size, int shmflg);
// 使用 shmat() 来附上共享内存段，使该段成为调用进程的虚拟内存的一部分。此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。
void *shmat(int shmid, const void *shmaddr, int shmflg);
// 调用 shmdt() 来分离共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。
int shmdt(const void *shmaddr);
// 调用 shmctl() 来删除共享内存段。当前所有附加内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
key_t ftok(const char *pathname, int proj_id);

示例

  • read_shm.c
    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
    #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <string.h>

    int main() {    

        // 1.获取一个共享内存
        int shmid = shmget(100, 0, IPC_CREAT);
        printf("shmid : %d\n", shmid);

        // 2.和当前进程进行关联
        void * ptr = shmat(shmid, NULL, 0);

        // 3.读数据
        printf("%s\n", (char *)ptr);
        
        printf("按任意键继续\n");
        getchar();

        // 4.解除关联
        shmdt(ptr);

        // 5.删除共享内存
        shmctl(shmid, IPC_RMID, NULL);

        return 0;
    }
  • write_shm.c
    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
    #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <string.h>

    int main() {    

        // 1.创建一个共享内存
        int shmid = shmget(100, 4096, IPC_CREAT | 0664);
        printf("shmid : %d\n", shmid);
        
        // 2.和当前进程进行关联
        void * ptr = shmat(shmid, NULL, 0);

        char * str = "helloworld";
        // 3.写数据
        memcpy(ptr, str, strlen(str) + 1);
        
        printf("按任意键继续\n");
        getchar();

        // 4.解除关联
        shmdt(ptr);

        // 5.删除共享内存
        shmctl(shmid, IPC_RMID, NULL);

        return 0;
    }

操作命令

1
2
3
4
5
6
7
8
9
10
11
12
# ipcs 用法
ipcs -a # 打印当前系统中所有的进程间通信方式的信息
ipcs -m # 打印出使用共享内存进行进程间通信的信息
ipcs -q # 打印出使用消息队列进行进程间通信的信息
ipcs -s # 打印出使用信号进行进程间通信的信息
# ipcrm 用法
ipcrm -M shmkey # 移除用shmkey创建的共享内存段
ipcrm -m shmid  # 移除用shmid标识的共享内存段
ipcrm -Q msgkey # 移除用msqkey创建的消息队列
ipcrm -q msqid  # 移除用msqid标识的消息队列
ipcrm -S semkey # 移除用semkey创建的信号
ipcrm -s semid  # 移除用semid标识的信号

信号

信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

使用

使用信号的两个主要目的是：（1）让进程知道已经发生了一个特定的事情；（2）强迫进程执行它自己代码中的信号处理程序。
查看系统定义的信号列表：kill –l。前 31 个信号为常规信号，其余为实时信号。

信号相关的函数

1
2
3
4
5
int kill(pid_t pid, int sig);
int raise(int sig);
void abort(void);
unsigned int alarm(unsigned int seconds);
int setitimer(int which, const struct itimerval *new_val, struct itimerval *old_value);
  • alarm.c
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    // 1秒钟电脑能数多少个数？
    #include <stdio.h>
    #include <unistd.h>
    /*
        实际的时间 = 内核时间 + 用户时间 + 消耗的时间
        进行文件IO操作的时候比较浪费时间

        定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。
    */

    int main() {    

        alarm(1);

        int i = 0;
        while(1) {
            printf("%i\n", i++);
        }

        return 0;
    }
  • setitimer.c
    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
    /*
        #include <sys/time.h>
        int setitimer(int which, const struct itimerval *new_value,
                            struct itimerval *old_value);
            - 功能：设置定时器（闹钟）。可以替代alarm函数。精度微妙us，可以实现周期性定时
            - 参数：
                - which : 定时器以什么时间计时
                  ITIMER_REAL: 真实时间，时间到达，发送 SIGALRM   常用
                  ITIMER_VIRTUAL: 用户时间，时间到达，发送 SIGVTALRM
                  ITIMER_PROF: 以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF

                - new_value: 设置定时器的属性
                    struct itimerval {      // 定时器的结构体
                        struct timeval it_interval;  // 每个阶段的时间，间隔时间
                        struct timeval it_value;     // 延迟多长时间执行定时器
                    };

                    struct timeval {        // 时间的结构体
                        time_t      tv_sec;     //  秒数     
                        suseconds_t tv_usec;    //  微秒    
                    };
               
                - old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL
            
            - 返回值：
                成功 0
                失败 -1 并设置错误号
    */
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>

    // 过3秒以后，每隔2秒钟定时一次
    int main() {

        struct itimerval new_value;

        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;

        // 设置延迟的时间,3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;

        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");

        if(ret == -1) {
            perror("setitimer");
            exit(0);
        }

        getchar();

        return 0;
    }

信号捕捉函数

1
2
sighandler_t signal(int signum, sighandler_t handler);
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
  • signal.c
    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
    /*
        #include <signal.h>
        typedef void (*sighandler_t)(int);
        sighandler_t signal(int signum, sighandler_t handler);
            - 功能：设置某个信号的捕捉行为
            - 参数：
                - signum: 要捕捉的信号
                - handler: 捕捉到信号要如何处理
                    - SIG_IGN ： 忽略信号
                    - SIG_DFL ： 使用信号默认的行为
                    - 回调函数 :  这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。
                        - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
                        - 不是程序员调用，而是当信号产生，由内核调用
                        - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。
            - 返回值：
                成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
                失败，返回SIG_ERR，设置错误号
    */
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>

    void myalarm(int num) {
        printf("捕捉到了信号的编号是：%d\n", num);
        printf("xxxxxxx\n");
    }

    // 过3秒以后，每隔2秒钟定时一次
    int main() {

        // 注册信号捕捉
        // signal(SIGALRM, SIG_IGN);
        // signal(SIGALRM, SIG_DFL);
        // void (*sighandler_t)(int); // 函数指针，int类型的参数表示捕捉到的信号的值。
        signal(SIGALRM, myalarm);

        struct itimerval new_value;

        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;

        // 设置延迟的时间, 3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;

        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");

        if(ret == -1) {
            perror("setitimer");
            exit(0);
        }

        getchar();

        return 0;
    }
  • sigaction.c
    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
    /*
        #include <signal.h>
        int sigaction(int signum, const struct sigaction *act,
                                struct sigaction *oldact);
            - 功能：检查或者改变信号的处理。信号捕捉
            - 参数：
                - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
                - act ：捕捉到信号之后的处理动作
                - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
            - 返回值：
                成功 0
                失败 -1
    */
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>

    void myalarm(int num) {
        printf("捕捉到了信号的编号是：%d\n", num);
        printf("xxxxxxx\n");
    }

    // 过3秒以后，每隔2秒钟定时一次
    int main() {

        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myalarm;
        sigemptyset(&act.sa_mask);  // 清空临时阻塞信号集
       
        // 注册信号捕捉
        sigaction(SIGALRM, &act, NULL);

        struct itimerval new_value;

        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;

        // 设置延迟的时间,3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;

        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");

        if(ret == -1) {
            perror("setitimer");
            exit(0);
        }

        // getchar();
        while(1);

        return 0;
    }

信号集相关操作函数

1
2
3
4
5
6
7
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signum);
int sigdelset(sigset_t *set, int signum);
int sigismember(const sigset_t *set, int signum);
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
int sigpending(sigset_t *set);
  • sigprocmask.c
    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
    /*
        int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
            - 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）
            - 参数：
                - how : 如何对内核阻塞信号集进行处理
                    SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
                        假设内核中默认的阻塞信号集是mask， mask | set
                    SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
                        mask &= ~set
                    SIG_SETMASK:覆盖内核中原来的值
                
                - set ：已经初始化好的用户自定义的信号集
                - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
            - 返回值：
                成功：0
                失败：-1
                    设置错误号：EFAULT、EINVAL

        int sigpending(sigset_t *set);
            - 功能：获取内核中的未决信号集
            - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。
    */

    // 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕
    // 设置某些信号是阻塞的，通过键盘产生这些信号
    #include <stdio.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <unistd.h>

    int main() {

        // 设置2、3号信号阻塞
        sigset_t set;
        sigemptyset(&set);
        // 将2号和3号信号添加到信号集中
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGQUIT);

        // 修改内核中的阻塞信号集
        sigprocmask(SIG_BLOCK, &set, NULL);

        int num = 0;

        while(1) {
            num++;
            // 获取当前的未决信号集的数据
            sigset_t pendingset;
            sigemptyset(&pendingset);
            sigpending(&pendingset);

            // 遍历前32位
            for(int i = 1; i <= 31; i++) {
                if(sigismember(&pendingset, i) == 1) {
                    printf("1");
                } else if(sigismember(&pendingset, i) == 0) {
                    printf("0");
                } else {
                    perror("sigismember");
                    exit(0);
                }
            }

            printf("\n");
            sleep(1);
            if(num == 10) {
                // 解除阻塞
                sigprocmask(SIG_UNBLOCK, &set, NULL);
            }
        }

        return 0;
    }
  • sigset.c
    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
    /*
        以下信号集相关的函数都是对自定义的信号集进行操作。

        int sigemptyset(sigset_t *set);
            - 功能：清空信号集中的数据,将信号集中的所有的标志位置为0
            - 参数：set,传出参数，需要操作的信号集
            - 返回值：成功返回0， 失败返回-1

        int sigfillset(sigset_t *set);
            - 功能：将信号集中的所有的标志位置为1
            - 参数：set,传出参数，需要操作的信号集
            - 返回值：成功返回0， 失败返回-1

        int sigaddset(sigset_t *set, int signum);
            - 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号
            - 参数：
                - set：传出参数，需要操作的信号集
                - signum：需要设置阻塞的那个信号
            - 返回值：成功返回0， 失败返回-1

        int sigdelset(sigset_t *set, int signum);
            - 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号
            - 参数：
                - set：传出参数，需要操作的信号集
                - signum：需要设置不阻塞的那个信号
            - 返回值：成功返回0， 失败返回-1

        int sigismember(const sigset_t *set, int signum);
            - 功能：判断某个信号是否阻塞
            - 参数：
                - set：需要操作的信号集
                - signum：需要判断的那个信号
            - 返回值：
                1 ： signum被阻塞
                0 ： signum不阻塞
                -1 ： 失败
    */
    #include <signal.h>
    #include <stdio.h>

    int main() {

        // 创建一个信号集
        sigset_t set;

        // 清空信号集的内容
        sigemptyset(&set);

        // 判断 SIGINT 是否在信号集 set 里
        int ret = sigismember(&set, SIGINT);
        if(ret == 0) {
            printf("SIGINT 不阻塞\n");
        } else if(ret == 1) {
            printf("SIGINT 阻塞\n");
        }

        // 添加几个信号到信号集中
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGQUIT);

        // 判断SIGINT是否在信号集中
        ret = sigismember(&set, SIGINT);
        if(ret == 0) {
            printf("SIGINT 不阻塞\n");
        } else if(ret == 1) {
            printf("SIGINT 阻塞\n");
        }

        // 判断SIGQUIT是否在信号集中
        ret = sigismember(&set, SIGQUIT);
        if(ret == 0) {
            printf("SIGQUIT 不阻塞\n");
        } else if(ret == 1) {
            printf("SIGQUIT 阻塞\n");
        }

        // 从信号集中删除一个信号
        sigdelset(&set, SIGQUIT);

        // 判断SIGQUIT是否在信号集中
        ret = sigismember(&set, SIGQUIT);
        if(ret == 0) {
            printf("SIGQUIT 不阻塞\n");
        } else if(ret == 1) {
            printf("SIGQUIT 阻塞\n");
        }

        return 0;
    }
#进程
Linux系统编程-进程
https://lcf163.github.io/2021/04/08/Linux系统编程-进程/
作者
乘风的小站
发布于
2021年4月8日
许可协议