linux的进程间通信概述

进程间通信（IPC，Inter - Process Communication）是指在不同进程之间进行数据交换和同步的机制。由于每个进程都有自己独立的地址空间，直接共享内存存在困难，因此需要专门的 IPC 机制来实现进程之间的交互。常见的 IPC 机制有管道、消息队列、共享内存、信号量、套接字等，它们各自适用于不同的场景，具有不同的优缺点。

linux的IPC机制-管道

管道是一种最基本的 IPC 机制，它用于在两个进程之间单向传输数据。管道分为匿名管道和命名管道。匿名管道只能用于具有亲缘关系（如父子进程）的进程之间通信，它通过pipe函数创建。命名管道（FIFO）则可以用于任意两个进程之间通信，它通过mkfifo函数创建。在使用管道时，一个进程向管道写入数据，另一个进程从管道读取数据，数据按照先进先出（FIFO）的顺序传输。

匿名管道

概念
匿名管道是一种半双工的通信方式，即数据只能在一个方向上流动，**通常用于具有亲缘关系的进程（如父子进程）之间进行通信。**它没有实际的文件系统实体与之关联，只能在创建它的进程及其子进程中使用。
工作原理
当一个进程调用pipe()系统调用时，操作系统会创建一个匿名管道，并返回两个文件描述符，一个用于读取（fd[0]），另一个用于写入（fd[1]）。
进程可以通过write()系统调用向写端文件描述符写入数据，而另一个进程可以通过read()系统调用从读端文件描述符读取数据。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>#define BUFFER_SIZE 1024int main() {int pipe_fd[2];pid_t child_pid;char buffer[BUFFER_SIZE];// 创建匿名管道if (pipe(pipe_fd) == -1) {perror("pipe");return EXIT_FAILURE;}// 创建子进程child_pid = fork();if (child_pid == -1) {perror("fork");return EXIT_FAILURE;} else if (child_pid == 0) {  // 子进程close(pipe_fd[1]);  // 关闭写端ssize_t bytes_read = read(pipe_fd[0], buffer, BUFFER_SIZE - 1);if (bytes_read == -1) {perror("read");return EXIT_FAILURE;}buffer[bytes_read] = '\0';printf("Child process received: %s\n", buffer);close(pipe_fd[0]);  // 关闭读端} else {  // 父进程close(pipe_fd[0]);  // 关闭读端const char *message = "Hello from parent!";ssize_t bytes_written = write(pipe_fd[1], message, strlen(message));if (bytes_written == -1) {perror("write");return EXIT_FAILURE;}close(pipe_fd[1]);  // 关闭写端}return EXIT_SUCCESS;
}

stdio.h：提供标准输入输出函数，像printf这类函数就出自该头文件。
stdlib.h：包含了一些常用的函数，例如EXIT_SUCCESS和EXIT_FAILURE等常量的定义。
unistd.h：提供了许多 Unix 标准的系统调用，像pipe、fork、read、write和close这些函数就在其中。
string.h：提供字符串处理函数，例如strlen。
定义了一个常量BUFFER_SIZE，其值为 1024，此常量用于指定缓冲区的大小。
pipe_fd[2]：这是一个包含两个元素的整型数组，用于存储管道的文件描述符。pipe_fd[0]是读端，pipe_fd[1]是写端。
child_pid：用于存储fork函数的返回值，以此判断当前是父进程还是子进程。
buffer：用于存储从管道读取的数据。
pipe(pipe_fd)：调用pipe函数创建一个匿名管道，若创建成功，pipe_fd[0]会被初始化为读端的文件描述符，pipe_fd[1]会被初始化为写端的文件描述符。
若创建失败，pipe函数会返回 -1，此时调用perror(“pipe”)输出错误信息，并且程序以失败状态退出。
fork()：调用fork函数创建一个新的子进程。此函数在父进程中返回子进程的进程 ID，在子进程中返回 0，若创建失败则返回 -1。
若fork失败，perror(“fork”)会输出错误信息，程序以失败状态退出。
若child_pid为 0，表明当前是子进程。
close(pipe_fd[1])：子进程不需要写管道，所以关闭写端。
read(pipe_fd[0], buffer, BUFFER_SIZE - 1)：从管道的读端读取数据，将其存储到buffer中，最多读取BUFFER_SIZE - 1字节。read函数返回实际读取的字节数。
若read失败，perror(“read”)会输出错误信息，程序以失败状态退出。
buffer[bytes_read] = ‘\0’：在读取的数据末尾添加字符串结束符，把buffer转换为一个以\0结尾的字符串。
printf(“Child process received: %s\n”, buffer)：输出从管道读取的数据。
close(pipe_fd[0])：读取完成后，关闭管道的读端。
通过匿名管道实现了父子进程间的通信。父进程向管道写入消息，子进程从管道读取消息并输出。

命名管道

概念
命名管道是一种在文件系统中具有实际名称的管道，**它可以在不具有亲缘关系的进程之间进行通信。**命名管道以文件的形式存在于文件系统中，但它实际上是一种特殊的文件，用于在进程间传递数据。
工作原理
进程可以通过mkfifo()系统调用创建一个命名管道，该管道会在文件系统中创建一个特殊的文件。
其他进程可以通过open()系统调用打开这个命名管道文件，进行读写操作，就像操作普通文件一样。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>#define FIFO_NAME "my_fifo"
#define BUFFER_SIZE 1024int main() {int fd;char buffer[BUFFER_SIZE];const char *message = "Hello from writer!";// 创建命名管道if (mkfifo(FIFO_NAME, 0666) == -1 && errno != EEXIST) {perror("mkfifo");return EXIT_FAILURE;}// 打开命名管道进行写操作fd = open(FIFO_NAME, O_WRONLY);if (fd == -1) {perror("open");return EXIT_FAILURE;}ssize_t bytes_written = write(fd, message, strlen(message));if (bytes_written == -1) {perror("write");return EXIT_FAILURE;}close(fd);return EXIT_SUCCESS;
}

stdio.h：提供标准输入输出函数，例如printf、perror等。
stdlib.h：包含标准库函数，这里用到了EXIT_SUCCESS和EXIT_FAILURE两个宏，用于表示程序的退出状态。
fcntl.h：提供文件控制相关的函数和常量，像open函数以及O_WRONLY这样的标志就定义在其中。
unistd.h：提供 Unix 标准的系统调用，例如mkfifo、write、close等。
string.h：提供字符串处理函数，这里使用了strlen来计算字符串的长度。
FIFO_NAME：定义了命名管道的名称，程序会使用这个名称来创建和操作命名管道。
BUFFER_SIZE：定义了缓冲区的大小，不过在这段代码中，该缓冲区未被实际使用。
fd：文件描述符，用于标识打开的命名管道，后续对管道的读写操作会用到它。
buffer：大小为BUFFER_SIZE的字符数组，不过在当前代码中没有被使用。
message：指向一个常量字符串的指针，该字符串是要写入命名管道的消息内容。
mkfifo(FIFO_NAME, 0666)：调用mkfifo函数创建一个命名管道，FIFO_NAME是管道的名称，0666是管道的权限，表示所有用户都有读写权限。
errno != EEXIST：如果mkfifo返回 -1 且errno的值为EEXIST，说明命名管道已经存在，这不是一个错误情况；只有当errno不是EEXIST时，才表明创建管道出现了真正的错误。
perror(“mkfifo”)：若创建管道失败，使用perror函数输出错误信息。
return EXIT_FAILURE：程序以失败状态退出。
open(FIFO_NAME, O_WRONLY)：调用open函数以只写模式打开命名管道，O_WRONLY表示只写。
fd == -1：若open返回 -1，说明打开管道失败，使用perror函数输出错误信息，程序以失败状态退出。

write(fd, message, strlen(message))：调用write函数将message指向的字符串写入到命名管道中，strlen(message)是要写入的字节数。
bytes_written == -1：若write返回 -1，说明写入操作失败，使用perror函数输出错误信息，程序以失败状态退出。

close(fd)：调用close函数关闭命名管道。
return EXIT_SUCCESS：程序以成功状态退出。

读端

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>#define FIFO_NAME "my_fifo"
#define BUFFER_SIZE 1024int main() {int fd;char buffer[BUFFER_SIZE];// 打开命名管道进行读操作fd = open(FIFO_NAME, O_RDONLY);if (fd == -1) {perror("open");return EXIT_FAILURE;}ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE - 1);if (bytes_read == -1) {perror("read");return EXIT_FAILURE;}buffer[bytes_read] = '\0';printf("Reader received: %s\n", buffer);close(fd);return EXIT_SUCCESS;
}

SystemV IPC介绍

SystemV IPC 是 UNIX System V 操作系统中引入的一组进程间通信机制，包括消息队列、共享内存和信号量。这些机制在 Linux 系统中也得到了广泛应用。​

消息队列

消息队列：消息队列是一个消息的链表，进程可以向消息队列发送消息，也可以从消息队列接收消息。消息队列中的消息具有特定的类型，接收进程可以根据消息类型选择性地接收消息。​
发送端

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>#define MSG_SIZE 128
#define MSG_TYPE 1typedef struct {long mtype;char mtext[MSG_SIZE];
} Message;int main() {key_t key;int msgid;Message message;// 获取键值key = ftok(".", 'a');if (key == -1) {perror("ftok");return EXIT_FAILURE;}// 创建消息队列msgid = msgget(key, IPC_CREAT | 0666);if (msgid == -1) {perror("msgget");return EXIT_FAILURE;}message.mtype = MSG_TYPE;strcpy(message.mtext, "Hello from sender!");// 发送消息if (msgsnd(msgid, &message, strlen(message.mtext) + 1, 0) == -1) {perror("msgsnd");return EXIT_FAILURE;}return EXIT_SUCCESS;
}

stdio.h：提供标准输入输出函数，例如printf、perror。
stdlib.h：包含标准库函数，如EXIT_SUCCESS和EXIT_FAILURE，用于表示程序的退出状态。
sys/types.h：定义了一些系统数据类型，如key_t、size_t等。
sys/ipc.h：提供了与进程间通信（IPC）相关的函数和常量，如ftok函数。
sys/msg.h：提供了消息队列相关的函数和常量，如msgget、msgsnd等。
string.h：提供字符串处理函数，如strcpy、strlen。
MSG_SIZE：定义了消息文本的最大长度，即Message结构体中mtext数组的大小。
MSG_TYPE：定义了消息的类型，在消息队列中，不同类型的消息可以被不同的接收端有选择地接收。

定义了一个名为Message的结构体，用于表示消息队列中的消息。
mtype：消息的类型，是一个长整型，用于区分不同类型的消息。
mtext：消息的文本内容，是一个字符数组，大小为MSG_SIZE。

key：用于唯一标识一个消息队列，是ftok函数生成的键值。
msgid：消息队列的标识符，是msgget函数返回的消息队列 ID。
message：Message结构体类型的变量，用于存储要发送的消息。

ftok函数用于生成一个唯一的键值，该键值将用于标识消息队列。
.：表示当前工作目录，作为生成键值的路径。
‘a’：是一个项目 ID，与路径一起生成唯一的键值。
如果ftok函数返回 -1，表示生成键值失败，使用perror输出错误信息并以失败状态退出程序。
msgget函数用于创建或获取一个消息队列。
key：是ftok生成的键值，用于标识消息队列。
IPC_CREAT | 0666：IPC_CREAT表示如果消息队列不存在则创建它，0666是消息队列的权限，表示所有用户都有读写权限。
如果msgget函数返回 -1，表示创建或获取消息队列失败，使用perror输出错误信息并以失败状态退出程序。
将消息的类型设置为MSG_TYPE，即之前定义的消息类型。
strcpy：使用strcpy函数将字符串"Hello from sender!"复制到message.mtext中。
msgsnd函数用于将消息发送到消息队列中。
msgid：是消息队列的标识符。
&message：是要发送的消息的指针。
strlen(message.mtext) + 1：是要发送的消息的长度，包括字符串结束符’\0’。
0：表示如果消息队列已满则阻塞等待。
如果msgsnd函数返回 -1，表示发送消息失败，使用perror输出错误信息并以失败状态退出程序。
代码实现了通过消息队列发送消息的功能，包括生成键值、创建消息队列、填充消息内容并发送消息。

接收端

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>#define MSG_SIZE 128
#define MSG_TYPE 1typedef struct {long mtype;char mtext[MSG_SIZE];
} Message;int main() {key_t key;int msgid;Message message;// 获取键值key = ftok(".", 'a');if (key == -1) {perror("ftok");return EXIT_FAILURE;}// 获取消息队列msgid = msgget(key, 0);if (msgid == -1) {perror("msgget");return EXIT_FAILURE;}// 接收消息if (msgrcv(msgid, &message, MSG_SIZE, MSG_TYPE, 0) == -1) {perror("msgrcv");return EXIT_FAILURE;}printf("Receiver received: %s\n", message.mtext);return EXIT_SUCCESS;
}

key：类型为key_t，用于存储通过ftok函数生成的唯一键值，该键值用于标识消息队列。
msgid：是一个整数，用于存储消息队列的标识符，后续接收消息的操作会用到它。
message：是Message结构体类型的变量，此结构体在之前的代码中应该已经定义，用来存储从消息队列接收的消息。
ftok函数的作用是根据给定的路径名和项目 ID 生成一个系统范围内唯一的键值。
.：代表当前工作目录，作为生成键值的路径依据。
‘a’：是项目 ID，与路径共同生成唯一的键值。
若ftok函数返回 -1，意味着键值生成失败。此时调用perror(“ftok”)输出错误信息，程序以失败状态退出。

msgget函数用于获取一个已经存在的消息队列。
key：是前面通过ftok生成的键值，用于定位消息队列。
0：表示不创建新的消息队列，仅尝试获取已存在的消息队列。
若msgget函数返回 -1，说明获取消息队列失败。调用perror(“msgget”)输出错误信息，程序以失败状态退出。
msgrcv函数用于从消息队列中接收消息。
msgid：消息队列的标识符，指定从哪个消息队列接收消息。
&message：指向Message结构体变量的指针，用于存储接收到的消息。
MSG_SIZE：指定接收消息时mtext字段的最大长度，防止接收数据时发生缓冲区溢出。
MSG_TYPE：指定要接收的消息类型，只有消息类型匹配的消息才会被接收。
0：表示若消息队列中没有指定类型的消息，函数会阻塞等待，直到有符合条件的消息到来。
若msgrcv函数返回 -1，表明接收消息失败。调用perror(“msgrcv”)输出错误信息，程序以失败状态退出。
通过消息队列接收指定类型的消息，并将接收到的消息内容输出。它依赖于之前发送端程序创建的消息队列和发送的消息。

共享内存

共享内存：共享内存允许多个进程共享同一块内存区域，这是一种高效的 IPC 机制，因为进程可以直接读写共享内存，而无需像管道那样进行数据复制。但由于多个进程同时访问共享内存可能会导致竞态条件，需要结合信号量等同步机制来保证数据的一致性。​

写入端

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>#define SHM_SIZE 1024int main() {key_t key;int shmid;char *shm_ptr;// 获取键值key = ftok(".", 'a');if (key == -1) {perror("ftok");return EXIT_FAILURE;}// 创建共享内存段shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);if (shmid == -1) {perror("shmget");return EXIT_FAILURE;}// 连接共享内存段到进程地址空间shm_ptr = shmat(shmid, NULL, 0);if (shm_ptr == (void *)-1) {perror("shmat");return EXIT_FAILURE;}const char *message = "Hello from writer to shared memory!";strcpy(shm_ptr, message);// 分离共享内存段if (shmdt(shm_ptr) == -1) {perror("shmdt");return EXIT_FAILURE;}return EXIT_SUCCESS;
}

stdio.h：提供标准输入输出函数，如 printf 和 perror。
stdlib.h：包含标准库函数和常量，如 EXIT_SUCCESS 和 EXIT_FAILURE。
sys/types.h：定义了一些系统数据类型，如 key_t。
sys/ipc.h：提供进程间通信（IPC）相关的函数和常量，如 ftok。
sys/shm.h：提供共享内存操作的函数和常量，如 shmget、shmat 和 shmdt。
string.h：提供字符串处理函数，如 strcpy。
key：类型为 key_t，用于存储通过 ftok 函数生成的唯一键值，该键值用于标识共享内存段。
shmid：整数类型，用于存储共享内存段的标识符，后续的共享内存操作会用到它。
shm_ptr：字符指针，用于指向连接到进程地址空间后的共享内存段。

ftok 函数根据指定的路径名（. 表示当前工作目录）和项目 ID（‘a’）生成一个系统范围内唯一的键值。
如果 ftok 函数返回 -1，表示生成键值失败，使用 perror 输出错误信息并以失败状态退出程序。
shmget 函数用于创建或获取一个共享内存段。
key：是前面生成的键值，用于标识共享内存段。
SHM_SIZE：指定共享内存段的大小。
IPC_CREAT | 0666：IPC_CREAT 表示如果共享内存段不存在则创建它，0666 是共享内存段的权限，表示所有用户都有读写权限。
如果 shmget 函数返回 -1，表示创建或获取共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
shmat 函数将指定的共享内存段连接到当前进程的地址空间。
shmid：是共享内存段的标识符。
NULL：表示让系统自动选择一个合适的地址来连接共享内存段。
0：表示以默认的读写权限连接共享内存段。
如果 shmat 函数返回 (void *)-1，表示连接共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
shmdt 函数将共享内存段从当前进程的地址空间中分离。
如果 shmdt 函数返回 -1，表示分离共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
创建共享内存段、连接到该共享内存段、向其中写入数据，最后分离共享内存段的功能。其他进程可以通过相同的键值连接到这个共享内存段并读取其中的数据，从而实现进程间的数据共享。

读取端

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>#define SHM_SIZE 1024int main() {key_t key;int shmid;char *shm_ptr;// 获取键值key = ftok(".", 'a');if (key == -1) {perror("ftok");return EXIT_FAILURE;}// 获取共享内存段shmid = shmget(key, SHM_SIZE, 0);if (shmid == -1) {perror("shmget");return EXIT_FAILURE;}// 连接共享内存段到进程地址空间shm_ptr = shmat(shmid, NULL, 0);if (shm_ptr == (void *)-1) {perror("shmat");return EXIT_FAILURE;}printf("Reader read from shared memory: %s\n", shm_ptr);// 分离共享内存段if (shmdt(shm_ptr) == -1) {perror("shmdt");return EXIT_FAILURE;}return EXIT_SUCCESS;
}

key：类型为key_t，用于存储由ftok函数生成的唯一键值，这个键值用于标识共享内存段。
shmid：整数类型，代表共享内存段的标识符，后续的共享内存操作会用到它。
shm_ptr：字符指针，指向连接到进程地址空间后的共享内存段，方便对共享内存中的数据进行读写操作。
ftok函数会根据指定的路径名（. 表示当前工作目录）和项目 ID（‘a’）生成一个系统范围内唯一的键值。这个键值是后续定位共享内存段的关键。
若ftok函数返回 -1，意味着键值生成失败。此时调用perror(“ftok”)输出错误信息，程序以失败状态退出。
shmget函数的作用是获取一个已经存在的共享内存段。
key：就是前面通过ftok函数生成的键值，用于定位共享内存段。
SHM_SIZE：指定共享内存段的大小，这里应该是之前创建共享内存段时使用的大小。
0：表示不创建新的共享内存段，仅尝试获取已存在的共享内存段。
若shmget函数返回 -1，说明获取共享内存段失败。调用perror(“shmget”)输出错误信息，程序以失败状态退出。
shmat函数将指定的共享内存段连接到当前进程的地址空间。
shmid：共享内存段的标识符。
NULL：表示让系统自动选择一个合适的地址来连接共享内存段。
0：表示以默认的读写权限连接共享内存段。
若shmat函数返回(void *)-1，意味着连接共享内存段失败。调用perror(“shmat”)输出错误信息，程序以失败状态退出。

shmdt函数的作用是将共享内存段从当前进程的地址空间中分离。
若shmdt函数返回 -1，表明分离共享内存段失败。调用perror(“shmdt”)输出错误信息，程序以失败状态退出。

代码实现了连接到已存在的共享内存段、读取其中的数据、输出数据，最后分离共享内存段的功能，与之前创建并写入共享内存段的程序配合，实现了进程间的数据共享。

信号量

信号量是一种用于实现进程同步和互斥的工具，它本质上是一个计数器。通过对信号量的操作（如 P 操作和 V 操作），进程可以控制对共享资源的访问，避免多个进程同时访问共享资源导致的数据错误。​
在 Linux 中，信号量操作主要通过semget、semop和semctl等函数来实现。semget用于创建或获取信号量集，semop用于执行信号量操作（P 操作和 V 操作），semctl用于控制信号量（如初始化信号量的值等）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <sys/shm.h>
#define SEM_KEY 1234
#define SHM_KEY 5678
#define SHM_SIZE 1024union semun {int val;struct semid_ds *buf;unsigned short *array;
};int main() {key_t key;int semid, shmid;char *shm_ptr;struct sembuf sem_ops[1];// 获取信号量集semid = semget(SEM_KEY, 1, IPC_CREAT | 0666);if (semid == -1) {perror("semget");return EXIT_FAILURE;}// 初始化信号量的值为1union semun arg;arg.val = 1;if (semctl(semid, 0, SETVAL, arg) == -1) {perror("semctl");return EXIT_FAILURE;}// 获取共享内存段shmid = shmget(SHM_KEY, SHM_SIZE, IPC_CREAT | 0666);if (shmid == -1) {perror("shmget");return EXIT_FAILURE;}// 连接共享内存段到进程地址空间shm_ptr = static_cast<char*>(shmat(shmid, NULL, 0));if (shm_ptr == (void *)-1) {perror("shmat");return EXIT_FAILURE;}// P操作（等待信号量）sem_ops[0].sem_num = 0;sem_ops[0].sem_op = -1;sem_ops[0].sem_flg = SEM_UNDO;if (semop(semid, sem_ops, 1) == -1) {perror("semop");return EXIT_FAILURE;}// 访问共享资源（这里简单地写入数据到共享内存）const char *message = "Accessed by process";strcpy(shm_ptr, message);// V操作（释放信号量）sem_ops[0].sem_op = 1;if (semop(semid, sem_ops, 1) == -1) {perror("semop");return EXIT_FAILURE;}// 分离共享内存段if (shmdt(shm_ptr) == -1) {perror("shmdt");return EXIT_FAILURE;}return EXIT_SUCCESS;
}

stdio.h：提供标准输入输出函数，如 printf 和 perror。
stdlib.h：包含标准库函数和常量，如 EXIT_SUCCESS 和 EXIT_FAILURE。
sys/types.h：定义了一些系统数据类型，如 key_t。
sys/ipc.h：提供进程间通信（IPC）相关的函数和常量，如 ftok。
sys/sem.h：提供信号量操作的函数和常量，如 semget、semctl 和 semop。
unistd.h：提供了一些 Unix 标准的系统调用和函数。
SEM_KEY：定义信号量集的键值，用于标识信号量集。
SHM_KEY：定义共享内存段的键值，用于标识共享内存段。
SHM_SIZE：定义共享内存段的大小为 1024 字节。

semun 联合体用于 semctl 函数的第四个参数，不同的操作需要使用联合体中的不同成员。
key：类型为 key_t，虽然这里定义了但未使用。
semid：整数类型，用于存储信号量集的标识符。
shmid：整数类型，用于存储共享内存段的标识符。
shm_ptr：字符指针，用于指向连接到进程地址空间后的共享内存段。
sem_ops：struct sembuf 类型的数组，用于存储信号量操作的相关信息。
semget 函数用于创建或获取一个信号量集。
SEM_KEY：是信号量集的键值。
1：表示信号量集中信号量的数量为 1。
IPC_CREAT | 0666：IPC_CREAT 表示如果信号量集不存在则创建它，0666 是信号量集的权限，表示所有用户都有读写权限。
如果 semget 函数返回 -1，表示创建或获取信号量集失败，使用 perror 输出错误信息并以失败状态退出程序。
semctl 函数用于控制信号量集。
semid：是信号量集的标识符。
0：表示要操作的信号量在信号量集中的索引，这里只有一个信号量，所以索引为 0。
SETVAL：表示要执行的操作是设置信号量的值。
arg：semun 联合体，arg.val = 1 表示将信号量的值设置为 1。
如果 semctl 函数返回 -1，表示设置信号量值失败，使用 perror 输出错误信息并以失败状态退出程序。
hmget 函数用于创建或获取一个共享内存段。
SHM_KEY：是共享内存段的键值。
SHM_SIZE：是共享内存段的大小。
IPC_CREAT | 0666：IPC_CREAT 表示如果共享内存段不存在则创建它，0666 是共享内存段的权限，表示所有用户都有读写权限。
如果 shmget 函数返回 -1，表示创建或获取共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
shmat 函数将指定的共享内存段连接到当前进程的地址空间。
shmid：是共享内存段的标识符。
NULL：表示让系统自动选择一个合适的地址来连接共享内存段。
0：表示以默认的读写权限连接共享内存段。
如果 shmat 函数返回 (void *)-1，表示连接共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
semop 函数用于对信号量集执行操作。
sem_ops[0].sem_num = 0：表示要操作的信号量在信号量集中的索引为 0。
sem_ops[0].sem_op = -1：表示将信号量的值减 1，如果信号量的值小于 0，则进程会阻塞等待。
sem_ops[0].sem_flg = SEM_UNDO：表示如果进程异常终止，系统会自动恢复信号量的值。
如果 semop 函数返回 -1，表示信号量操作失败，使用 perror 输出错误信息并以失败状态退出程序。
定义一个常量字符串 message。
使用 strcpy 函数将字符串 message 复制到共享内存段（由 shm_ptr 指向）中。

sem_ops[0].sem_op = 1：表示将信号量的值加 1，唤醒可能正在等待该信号量的进程。
如果 semop 函数返回 -1，表示信号量操作失败，使用 perror 输出错误信息并以失败状态退出程序。

shmdt 函数将共享内存段从当前进程的地址空间中分离。
如果 shmdt 函数返回 -1，表示分离共享内存段失败，使用 perror 输出错误信息并以失败状态退出程序。
代码通过信号量机制实现了对共享内存的互斥访问，确保在同一时间只有一个进程可以访问共享内存，避免了数据竞争和不一致的问题。