Linux - 进程通信

一、管道

管道是一种进程间通信（IPC）机制，用于在进程之间传递数据。它的本质是操作系统内核维护的一个内存缓冲区，配合文件描述符进行数据的读写。尽管管道的核心是内存缓冲区，但操作系统通过对管道的实现，让它看起来像文件一样可以用文件操作接口（如 read 和 write）来操作。因此，管道是一种特殊的文件，但并不用于数据的持久化存储。

1) 命名管道匿名管道

• 匿名管道：只能在具有亲缘关系的进程（如父进程和子进程）之间使用的通信机制。

  • 用于单个父进程及其子进程之间的通信。

  • 数据流仅在相关进程间传递，不会涉及文件系统。

  • pipe： 创建匿名管道

    int pipe(int pipefd[2])

    int pipefd[2];
    pipe(pipefd);
    

    • pipefd：一个包含两个文件描述符的数组，pipefd[0]（读端），pipefd[1]（写端）。
    • 返回值： 0表示成功，-1表示出错并设置errno。

• 命名管道：一种持久化的管道，它通过文件系统提供了一种通信接口，支持无亲缘关系的进程间通信。

  • mkfifo：系统调用用于创建命名管道文件。

    Bash: mkfifo [filename]

    mkfifo mypipe	// 创建名为mypipe的命名管道
    

    CPP： int mkfifo(const char *pathname, mode_t mode)

    mkfifo("mypipe", 0644);  // 创建名为mypipe的管道
    

    • pathname：要创建的命名管道的路径名。
    • mode：指定创建的命名管道的权限（与文件权限相同，例如 0644 表示所有者读写，组和其他用户只读）。
    • 返回值： 0表示成功，-1表示出错并设置errno

  • unlink：系统调用用于删除文件或目录的链接。

    Bash：unlink [filename]

    unlink myfifo  // 删除名为mypipe的管道
    

    CPP：int unlink(const char* pathname)

    unlink("mypipe");  // 删除名为mypipe的管道
    

    • pathname：要删除的文件或命名管道路径名。

    • 返回值： 0表示成功，-1表示出错并设置errno

2) 管道的特点

• 顺序读写

  • 管道数据是以字节流的形式从写端流入，从读端流出。
  • 只能按顺序读写，不支持随机访问。
  • 管道没有文件指针的概念，也不支持 seek 操作。

• 一次性传递

  • 数据通过管道从一个进程传递到另一个进程，读完即消失，无法重复读取。
  • 这意味着管道是临时的，不具备存储能力。

• 半双工通信

  • 管道默认是半双工的，数据只能在一个方向上传递（从写端到读端）。
  • 如果需要双向通信，可以创建两个管道，分别用于发送和接收。

• 基于文件描述符

  • 管道的读端和写端分别对应两个文件描述符，这两个文件描述符在相关的进程之间共享。
  • 管道的创建会返回一个文件描述符数组。
  • 进程退出管道也会自然而然释放。

• 容量有限

  • 管道的内存缓冲区大小是有限的（通常由操作系统设置，默认 4KB 或 64KB）。

  • 如果写端写入的数据超过缓冲区容量，写操作会阻塞，直到读端读取部分数据为止。

  • 当读取管道时，如果管道缓冲区中没有数据，读取的进程会阻塞，直到有数据写入为止。

• 面向字节流

  • 数据在写入管道时，会以字节为单位依次写入缓冲区，读端以相同的顺序读取。
  • 发送的数据没有明确的边界标记，读写操作只知道字节数量，而不是具体的内容分隔。
  • 管道不关心数据的具体格式（如文本、二进制、结构化数据等），只负责传输字节。
  • 如果需要有特定的格式或分隔符，程序需要自行定义和解析。
  • 面向字节流意味着管道只能按照写入数据的顺序读取，不能像文件一样支持随机访问（比如指定偏移量读取）。

父子进程之间协同工作时，会通过同步和互斥机制来协调资源访问，从而确保管道文件的数据传输安全可靠。

PIPE_BUF：是一个与管道相关的重要常量，定义了管道的写入操作可以原子性完成的最大数据量。

• 如果写入的字节数 ≤ PIPE_BUF，系统保证整个写入操作不会被其他进程的写入操作打断。
• 如果写入的字节数 > PIPE_BUF，系统可能会分成多个写操作，此时其他进程的写入可能会插入其中。

管道的4种情况：

• 读写端正常，管道如果为空，读端就要阻塞。
• 读写端正常，管道如果已满，写端就要阻塞。
• 读端正常，写端关闭，读端就会读到0，表明读到结尾，不会被阻塞。
• 写端关闭，读端正常，操作系统会通过信号13-SIGPIPE杀掉正在写入的进程。

3) 匿名管道与命名管道的比较

特性	匿名管道	命名管道
创建方式	使用 pipe() 创建	使用 mkfifo() 或 mknod() 创建
通信范围	仅限具有亲缘关系的进程	支持无亲缘关系的进程通信
存在时间	进程退出后自动销毁	文件存在于文件系统中，需手动删除
访问方式	基于文件描述符	通过文件路径访问
容量限制	操作系统设置的缓冲区大小（如 4KB/64KB）	操作系统设置的缓冲区大小
双向通信	需要创建两个匿名管道	需要创建两个命名管道

C 风格的可变参数函数使用头文件 <cstdarg> 中提供的宏，主要有以下几个步骤：

• 使用 ... 标记函数支持可变参数。
• 使用 va_list 类型声明参数列表。
• 使用 va_start 初始化参数列表。
• 使用 va_arg 依次读取参数。
• 使用 va_end 清理参数列表。

#include <iostream>
#include <cstdarg>  // 包含可变参数相关的宏using namespace std;// 求多个数的和
int sum(int count, ...) {va_list args;  // 声明参数列表va_start(args, count);  // 初始化参数列表，count 是最后一个固定参数int total = 0;for (int i = 0; i < count; ++i) {total += va_arg(args, int);  // 获取下一个参数}va_end(args);  // 清理参数列表return total;
}int main() {cout << sum(3, 1, 2, 3) << endl;  // 输出 6cout << sum(5, 1, 2, 3, 4, 5) << endl;  // 输出 15return 0;
}

二、共享内存

System V 共享内存是一种进程间通信（IPC）机制，它允许多个进程共享一块内存区域。通过这种机制，进程可以高效地交换数据，因为它避免了进程间的复制开销。

1) 共享内存系统调用

• ftok()：用于生成 唯一标识符 的函数，通常在 IPC（进程间通信，如共享内存、信号量、消息队列）中使用。

  key_t ftok(const char *pathname, int proj_id)

  key_t key = ftok(".", 65);
  

  • pathname：一个现有文件的路径名，必须是文件系统中实际存在的文件，通常会选择如 /tmp 或程序目录下的文件。
  • proj_id：用户自定义的值，用于确保生成的标识符在相同路径下依然唯一。
  • 返回值：返回一个 key_t 类型的唯一标识符（通常为整数类型），失败返回 -1，并设置 errno。

• shmget(): 创建共享内存段（share memory get）

  int shmget(key_t key, size_t size, int shmflg)

  // 创建一个共享内存段，大小为 1024 字节，权限为 0664
  int shmid = shmget(key, 1024, IPC_CREAT | 0666);
  

  • key：获取共享内存的时的唯一标识，创建时key就必须存在了。

  • size：共享内存段的大小。

  • shmflg：权限标志，类似文件权限。

    • IPC_CREAT：如果指定的 key 不存在，创建一个新的 IPC 对象（共享内存段、消息队列或信号量）,如果已存在，则会返回已有共享内段的标识符。
    • IPC_EXCL：不单独使用，配合IPC_CREAT 使用，即IPC_CREAT | IPC_EXCL，确保申请的共享内存是新的。如果指定的 key 对应的共享内存段已存在，返回错误，并设置 errno 为 EEXIST。
    • 权限设置：0666、0664。

  • 返回值：共享内存段的唯一标识符（shmid），失败返回 -1。

  1. 为什么不由操作系统统一生成key?

     • 如果操作系统随机生成 key，多个进程就需要额外的机制来共享这个 key，导致复杂性增加。

     • 程序重启时，如何保证仍能访问之前创建的 IPC 资源？而 ftok 的机制可以确保基于相同路径和 proj_id 得到相同的 key。

     • 系统生成的 key 可能会因时间或使用条件导致冲突，而 ftok 的方案让开发者可以根据路径和 proj_id 手动控制唯一性。

  2. key与shmid的关系

     • 两个程序想要获得一个共享内存段，我不需要去知道这个共享数据段的shmid是多少，我们两个约定好文件名，和指定的proj_id，用ftok生成对应对的唯一标识符，然后交给操作系统，操作系统统一维护共享内存段，返回给我他维护下的shmid，后续我用这个shmid操作就好。

     • key 在操作系统内标定唯一性。

     • shmid 在进程内，表示资源的唯一性。

     • 只需要记住：key 是给程序员用的，shmid 是给系统用的！

• shmat()：将共享内存挂载到进程地址空间（shared memory attach）

  void* shmat(int shmid, const void* shmaddr, int shmflg)

  // 将共享内存段附加到地址空间
  char* str = (char*) shmat(shmid, NULL, 0);  
  

  • shmid: shmget() 返回的共享内存段标识符。

  • shmaddr: 指定共享内存的附加地址，一般传 NULL。

  • shmflg: 附加标志，通常为 0。

  • 返回值：挂接到的进程空间地址。

• shmdt()：将共享内存段与当前进程脱离（shared memory detach）

  int shmdt(const void* shmaddr)

  // 分离共享内存段
  shmdt(str);  
  

  • shmaddr: shmat() 返回的共享内存地址。

  • 返回值：成功返回 0，失败返回 -1。

• shmctl()：控制共享内存（shared memory control）

  int shmctl(int shmid, int cmd, struct shmid_ds* buf)

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

  • shmid: shmget() 返回的共享内存段标识符。

  • cmd: 命令，如 IPC_RMID 用于删除共享内存段。

    • IPC_RMID：删除共享内存段。
    • IPC_STAT：把shmid_ds结构中的数据设置为共享内存当前的关联值。
    • IPC_SET：在进程有足够权限的前提下，把共享内存的当前关联值设置为shmid_ds数据结构种给出的值。

  • buf: 结构体指针，用于传递控制信息，删除时可为 NULL。

  • 返回值：

1. 创建和写入共享内存：

   #include <sys/ipc.h>
   #include <sys/shm.h>
   #include <stdio.h>
   #include <string.h>int main() {key_t key = ftok("shmfile", 65);  // 生成唯一的键值int shmid = shmget(key, 1024, 0666 | IPC_CREAT);  // 创建共享内存段char* str = (char*) shmat(shmid, NULL, 0);  // 将共享内存段附加到地址空间printf("Write Data: ");fgets(str, 1024, stdin);  // 写入共享内存printf("Data written in memory: %s\n", str);shmdt(str);  // 分离共享内存段return 0;
   

2. 读取共享内存：

   #include <sys/ipc.h>
   #include <sys/shm.h>
   #include <stdio.h>int main() {key_t key = ftok("shmfile", 65);  // 生成相同的键值int shmid = shmget(key, 1024, 0666);  // 获取共享内存段char* str = (char*) shmat(shmid, NULL, 0);  // 将共享内存段附加到地址空间printf("Data read from memory: %s\n", str);shmdt(str);  // 分离共享内存段shmctl(shmid, IPC_RMID, NULL);  // 删除共享内存段return 0;
   }
   

2) 共享内存原理

• 创建共享内存

  • 调用 shmget() 创建共享内存段。
  • 操作系统为共享内存段分配物理内存并生成一个唯一标识符（shmid）。
  • 系统维护一个共享内存段表（通常是内核数据结构的一部分），记录共享内存的元数据，例如大小、权限和引用计数等。

  1. 元数据存储 内核使用结构体 shmid_ds 保存共享内存段的元信息，例如：

     struct shmid_ds {struct ipc_perm shm_perm;	// 权限信息，存储了keysize_t shm_segsz;        	// 内存段大小time_t shm_atime;   		// 上次附加时间time_t shm_dtime;   		// 上次分离时间time_t shm_ctime;   		// 创建时间pid_t shm_cpid; 			// 创建共享内存的进程IDpid_t shm_lpid; 			// 最后访问共享内存的进程IDshmatt_t shm_nattch;	 // 当前附加到该共享内存段的进程数（即调用 shmat() 的进程数量）...
     };
     

  2. ipcs：查看创建的共享内存

     ipcs [options]

     ipcs -m
     

     • -m：仅显示共享内存的状态。
     • -q：仅显示消息队列的状态。
     • -s：仅显示信号量的状态。

• 内存映射

  • 调用 shmat() 时，操作系统将共享内存段的物理页映射到调用进程的虚拟地址空间。
  • 操作系统修改页表，将进程的虚拟地址指向共享内存的物理地址。
  • 返回的虚拟地址可以被进程直接访问，就像操作普通变量一样。

• 多进程访问

  • 不同进程调用 shmat() 后，它们的虚拟地址空间都指向同一块物理内存。
  • 通过修改物理内存，数据可被所有附加该共享内存段的进程访问。

• 分离与清理

  • 分离共享内存段
    • 调用 shmdt() 将共享内存从进程的虚拟地址空间解除映射。
    • 物理内存仍然存在，只要引用计数大于 0。
  • 删除共享内存段
    • 调用 shmctl() 使用 IPC_RMID 命令删除共享内存段。
    • 只有当所有进程都分离后，操作系统才会释放关联的物理内存。

  1. ipcrm：删除特定共享内存段

     ipcrm -m [shmid]

3) 共享内存的特点

共享内存的主要特点是高效、直接、低开销的进程间数据共享，但同时它也带来了进程间同步和安全性的问题，要求合理的同步机制来避免数据冲突和不一致。

• 高效的通信方式

  • 共享内存是进程间通信中最快的一种方式，因为它不需要通过内核进行数据的复制。数据在共享内存区域中直接共享，避免了进程间复制数据的开销。
  • 进程可以直接读写共享内存中的数据，而不需要进行数据的传输，减少了上下文切换的次数。

• 内存区共享

  • 多个进程可以将同一块物理内存映射到各自的虚拟地址空间中。这样，它们就可以通过访问这块共享的内存区域来交换数据。
  • 每个进程都有对共享内存的映射副本，它们可以像访问普通内存一样进行读写操作。

• 需要同步机制

  • 虽然多个进程可以共享内存中的数据，但这也带来了一些问题，比如竞争条件（race condition）和数据不一致（即使共享内存不写入任何数据也可以读取）。

  • 因此，使用共享内存时，通常需要额外的同步机制，如信号量、互斥锁或条件变量，来确保访问共享内存的进程之间的协调，避免同时修改同一数据而导致的不一致。

• 内存保护和访问权限

  • 共享内存区的访问权限可以通过操作系统的控制机制进行管理。不同进程可以拥有不同的访问权限（如读写、只读、只写等）。
  • 操作系统会保证进程在访问共享内存时不会越界访问或者破坏其他进程的数据。

• 生命周期管理

  • 共享内存的生命周期通常由操作系统来管理。一旦创建共享内存段，操作系统会分配一块物理内存区域，并允许多个进程映射和使用这块内存。进程可以通过shmdt（解除映射）操作来分离共享内存，但共享内存本身在进程终止后并不会自动销毁，通常需要通过shmctl或类似函数来删除。
  • 共享内存段的生命周期由调用 shmctl 的进程控制（即谁创建谁负责删除）

三、信号量

信号量（Semaphore）是进程间通信的一种重要机制，用于解决同步和互斥问题。它广泛应用于多线程编程和多进程编程中，帮助实现对共享资源的访问控制。

1) 信号量系统调用

• semget(): 创建和获取信号量集（semaphore get）

  int semget(key_t key, int nsems, int semflg)

  // 创建一个信号量，权限为 0666
  int semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666);
  

  • key：获取信号量时的唯一标识，创建时key就必须存在了。

  • nsems：信号量集中的信号量个数。

  • shmflg：权限标志，类似文件权限。

    • IPC_CREAT：如果指定的 key 不存在，创建一个新的 IPC 对象（共享内存段、消息队列或信号量）,如果已存在，则会返回已有共享内段的标识符。
    • IPC_EXCL：不单独使用，配合IPC_CREAT 使用，即IPC_CREAT | IPC_EXCL，确保申请的共享内存是新的。如果指定的 key 对应的共享内存段已存在，返回错误，并设置 errno 为 EEXIST。
    • 权限设置：0666、0664。

  • 返回值：共享内存段的唯一标识符（semid），失败返回 -1。

• semctl()：对信号量进行控制操作，包括初始化、获取值、删除等。

  int semctl(int semid, int semnum, int cmd, ...)

  // 初始化信号量值为 1
  semctl(semid, 0, SETVAL, 1);// 删除信号量
  semctl(semid, 0, IPC_RMID);
  

  • semid：信号量集的标识符。
  • semnum：信号量的索引（从 0 开始）。
  • cmd：控制命令
    • SETVAL：设置信号量的值。
    • cppGETVAL：获取信号量的值。
    • IPC_RMID：删除信号量集。
  • 可选参数arg：根据 cmd 的不同，可以是 int 或 union semun 类型的值。
  • 返回值：根据命令不同返回值不同，失败返回 -1。

• semop()：对信号量执行操作，如 P 操作（wait）或 V 操作（signal）。

  int semop(int semid, struct sembuf *sops, size_t nsops)

  struct sembuf p_op = {0, -1, 0};  // P 操作
  struct sembuf v_op = {0, 1, 0};   // V 操作
  // 执行 P 操作
  semop(semid, &p_op, 1);
  // 临界区代码// 执行 V 操作
  semop(semid, &v_op, 1);
  

  • semid：信号量集的标识符。

  • sops：操作数组，类型为 struct sembuf。

    // 结构定义
    struct sembuf {unsigned short sem_num; // 信号量索引short sem_op;           // 操作值 (-1: P 操作, +1: V 操作)short sem_flg;          // 操作标志（如 SEM_UNDO）
    };
    

  • nsops：操作的个数。

  • 返回值：成功返回0，失败返回-1.

进程通信的本质：让不同进程看到同一份资源。