「共享与协作：进程间通信的奥秘」

一.进程间通信概述

1.1概念

进程间通信（Inter-Process Communication，简称 IPC）是指不同进程之间进行数据交换和信息传递的机制和技术。在现代操作系统中，同时运行着多个进程，它们可能需要相互协作、共享数据或进行通信来完成特定任务。

进程间通信允许进程在同一台计算机上或不同计算机上进行交流和协作。通过进程间通信，进程可以通过共享数据、消息传递、信号量、管道等方式进行相互沟通和协作。

常见的进程间通信机制包括以下几种：

选择适当的进程间通信机制取决于应用程序的需求和环境。不同的机制具有不同的特性、效率和复杂性。正确使用进程间通信可以实现并发处理、资源共享和协作，从而提高应用程序的效率和可靠性。

1.2功能

进程之间进行通信的主要原因有以下几个：

通过进程间通信，不同进程之间可以实现信息交换、资源共享、任务协调和事件处理，从而提高系统的效率、可靠性、并发性和扩展性。进程间通信是构建复杂应用程序和多进程系统的重要基础。

二.无名管道

2.1特点

无名管道（Unnamed Pipe）是一种最简单的进程间通信机制，用于在具有父子关系的进程之间进行单向通信。无名管道是一个字节流，用于在一个进程中将输出连接到另一个进程的输入。以下是无名管道的一些详细介绍：

无名管道提供了一种简单而有效的进程间通信机制。然而，由于只支持单向通信且限制比较多，无名管道适用于特定的通信需求，如父子进程之间的简单数据交换。当需要双向通信、多个进程间通信或非相关进程间通信时，应该选择其他更复杂但适用的进程间通信机制。

2.2注意事项

注意事项：

1.当管道中无数据时，读操作会阻塞；管道中无数据，将写端关闭，读操作会立即返回
2.管道中装满（管道大小64K）数据写阻塞，一旦
3.有4k空间，写继续，直到写满为止
3.只有在管道的读端存在时，向管道中写入数据才有意义。否则，会导致管道破裂，向管道中写入数据的进程将收到内核传来的SIGPIPE信号 (通常Broken pipe错误)。

2.3编程实战

#include 
#include 
#include 

int main() {
    int pipefd[2]; // 用于存储无名管道的文件描述符

    if (pipe(pipefd) == -1) {
        perror("无名管道创建失败");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();

    if (pid > 0) {
        // 父进程
        close(pipefd[0]); // 关闭读取端

        char message[] = "Hello, 子进程!";
        write(pipefd[1], message, sizeof(message)); // 写入数据到管道

        close(pipefd[1]); // 关闭写入端
    } else if (pid == 0) {
        // 子进程
        close(pipefd[1]); // 关闭写入端

        char buffer[512];
        ssize_t numRead = read(pipefd[0], buffer, sizeof(buffer)); // 从管道读取数据

        printf("子进程接收到的数据：%.*s\n", (int)numRead, buffer);

        close(pipefd[0]); // 关闭读取端
    } else {
        perror("进程创建失败");
        exit(EXIT_FAILURE);
    }

    return 0;
}

这段代码使用 中的 pipe() 函数创建了一个无名管道。接着，使用 fork() 函数创建了一个子进程。
在父进程中，关闭了管道的读取端，然后使用 write() 函数向管道写入数据。最后，关闭了管道的写入端。

在子进程中，关闭了管道的写入端，然后使用 read() 函数从管道中读取数据到 buffer 缓冲区，并打印出来。最后，关闭了管道的读取端。

注意，在实际应用中，你可能需要添加错误检查和更完善的逻辑来处理数据的读取和写入。

三.有名管道

3.1有名管道特点

有名管道（Named Pipes）是一种在文件系统中有名字的特殊文件，用于进程间通信。以下是有名管道的几个特点：

由于有名管道在文件系统中具有唯一路径名，使得它们非常适合需要持久性进程间通信的应用程序，例如客户端和服务器应用程序之间的通信。

补充

1.有名管道可以使互不相关的两个进程互相通信。
2.有名管道可以通过路径名来指出，并且在文件系统中可见，但内容存放在内存中。
3.进程通过文件IO来操作有名管道
4.有名管道遵循先进先出规则，不支持lseek()操作
5.半双工通信

3.2有名管道注意事项

在使用有名管道（Named Pipes）进行进程间通信时，以下是一些需要注意的事项：

总之，在使用有名管道进行进程间通信时，需要考虑文件权限、同步和阻塞、缓冲区大小、错误处理等方面的因素，以确保通信的正确性、可靠性和安全性。

补充

1.以只写方式打开有名管道，写阻塞（open），直到另一个进程将读打开
2.以只读方式打开有名管道，读阻塞（open），直到另一个进程将写打开
3.以可读可写方式打开有名管道，管道中无数据，读阻塞，当管道中写满数据，写阻塞

3.3mkfifo函数

mkfifo() 是一个系统调用函数，用于创建有名管道（Named Pipes）。以下是该函数的原型和用法：

#include 

int mkfifo(const char *pathname, mode_t mode);

参数说明：

• pathname：要创建的有名管道的路径名。
• mode：创建的有名管道的权限（权限掩码）。使用 chmod 命令中的权限表示法，如 0666。

返回值：

• 成功时，返回0。
• 失败时，返回-1，并设置 errno 来指示具体错误。

示例用法：

#include 
#include 
#include 

int main() {
    const char *pathname = "/tmp/my_fifo";

    int result = mkfifo(pathname, 0666);
    if (result == 0) {
        printf("有名管道创建成功\n");
    } else {
        perror("有名管道创建失败");
        exit(EXIT_FAILURE);
    }

    return 0;
}

在上述示例中，mkfifo() 函数将创建一个 /tmp/my_fifo 的有名管道。如果创建成功，将打印一条成功消息；否则，将打印错误信息。

请确保确保创建的有名管道路径名的有效性和权限设置的正确性，并根据需要进行错误检查处理。

3.4编程实战

好的，以下是一个使用有名管道进行进程间通信的简单例子：

发送消息的进程（writer.c）：

#include 
#include 
#include 
#include 
#include 

int main() {
    const char *fifoPath = "/tmp/myfifo";
    int fd;

    // 创建有名管道
    mkfifo(fifoPath, 0666);

    // 打开管道以进行写操作
    fd = open(fifoPath, O_WRONLY);

    // 发送消息到管道
    const char *message = "Hello, reader!";
    write(fd, message, strlen(message) + 1);
    close(fd);

    return 0;
}

接收消息的进程（reader.c）：

#include 
#include 
#include 
#include 
#include 

int main() {
    const char *fifoPath = "/tmp/myfifo";
    int fd;
    char buffer[256];

    // 打开管道以进行读操作
    fd = open(fifoPath, O_RDONLY);

    // 从管道读取消息
    read(fd, buffer, sizeof(buffer));
    printf("接收到的消息: %s\n", buffer);
    close(fd);

    return 0;
}

在上述例子中，发送消息的进程使用 mkfifo() 函数创建了一个有名管道，并使用 open() 函数以只写模式打开了管道。然后，使用 write() 函数将消息写入管道中。

接收消息的进程同样使用 open() 函数以只读模式打开了相同的管道，并使用 read() 函数从管道中读取消息。然后，打印出接收到的消息。

请确保在运行这两个进程之前，在命令行中先编译它们：

gcc writer.c -o writer
gcc reader.c -o reader

然后，可以分别运行 ./writer 和 ./reader 来观察进程间通过有名管道进行的简单消息通信。

四.信号

4.1信号特点

信号（Signal）在操作系统中是一种进程间通信机制，用于向进程发送异步通知。以下是信号的几个特点：

需要注意，不同的操作系统可能支持不同的信号，并且有不同的信号编号和默认处理行为。因此，在使用信号时应仔细了解操作系统的信号机制和规范。

总的来说，信号提供了一种简单而有效的进程间通信机制，可以用于处理异步事件和相应外部通知。但是，使用信号时需要注意处理函数的可重入性、信号处理函数的执行上下文切换以及信号的可靠性等问题。

4.2信号注意事项

在处理信号时，以下是一些需要注意的事项：

以上是一些在处理信号时需要注意的事项。合理处理信号可以帮助应用程序与操作系统之间进行有效的通信和响应外部事件。然而，信号处理也是一个复杂的主题，需要仔细考虑各种因素和风险。

4.3信号响应方式

在处理信号时，有三种主要的信号响应方式：

要选择适当的信号响应方式，需要根据实际需求和特定的业务逻辑来决定。例如，对于某个关键的信号，可以选择自定义信号处理函数来执行特定任务，而对于其他一些信号可以选择忽略或采用默认行为。

需要注意的是，使用自定义信号处理函数时应保持函数的简洁和高效，避免耗时和不可重入的操作，以及需要合理处理信号处理函数与其他并发机制（如线程）之间的同步和互斥。

另外，还应注意某些无法被阻塞或处理的信号，如 SIGKILL 和 SIGSTOP，不能被忽略或自定义信号处理函数。这些信号的默认行为是直接终止进程或暂停进程，无法被拦截或处理。

4.4怎么产生信号

在操作系统中，有几种常见的方法可以产生信号：

需要注意的是，生成信号的能力通常受到用户的权限和操作系统对信号的限制。具体可生成的信号类型和权限可能因操作系统和用户的不同而有所不同。此外，特定信号的具体处理方式也由接收进程的信号处理机制决定。

4.5常用信号

以下是一些常见的信号及其默认编号及含义：

这些信号仅是一部分常用的信号，不同的操作系统和环境中可能还有其他系统特定的信号。可以使用命令 kill -l 查看系统支持的所有信号及其编号。另外，还可以通过自定义信号处理函数来处理这些信号，以满足特定应用程序的需求。

4.6函数接口

在 C 语言中，有一些常用的函数接口可用于处理信号。以下是一些常见的信号相关函数接口：

除了以上提到的函数，还有一些其他的信号相关函数接口，在不同的操作系统和平台上可能存在差异。因此，在编写处理信号的代码时，应该查阅相关的文档和手册，确保在目标平台上正确使用合适的函数接口。

4.7信号屏蔽函数

信号集屏蔽函数用于设置和操作信号集的屏蔽状态，以控制哪些信号会被阻塞。在 C 语言中，常用的信号集屏蔽函数有以下几个：

函数原型如下：

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

how 参数指定了对信号屏蔽字的修改方式，可以取以下三个值：

• SIG_BLOCK: 将 set 中的信号添加到当前信号屏蔽字中。
• SIG_UNBLOCK: 将 set 中的信号从当前信号屏蔽字中解除阻塞。
• SIG_SETMASK: 将当前信号屏蔽字替换为 set。

set 参数是一个指向信号集的指针，表示要添加或解除阻塞的信号集。

oldset 参数（可选）是一个用来保存之前信号屏蔽字的信号集指针。如果不为 NULL，则 oldset 指向的信号集会被填充为函数调用之前的信号屏蔽字。

调用 sigprocmask 函数后，进程的信号屏蔽字会根据 how 参数对 set 中指定的信号进行修改。

示例用法：

#include 
#include 

int main() {
    sigset_t newmask, oldmask;
    
    // 设置屏蔽信号集包含 SIGINT 和 SIGQUIT
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGINT);
    sigaddset(&newmask, SIGQUIT);
    
    // 阻塞 newmask 中的信号
    sigprocmask(SIG_BLOCK, &newmask, &oldmask);
    
    // 此处可以进行一些需要屏蔽信号的操作
    
    // 恢复原来的信号屏蔽字
    sigprocmask(SIG_SETMASK, &oldmask, NULL);
    
    return 0;
}

以上示例中，通过 sigprocmask 函数将 SIGINT 和 SIGQUIT 信号添加到当前进程的信号屏蔽字中，实现对这两个信号的阻塞。在执行需要阻塞信号的操作后，通过再次调用 sigprocmask 恢复原来的信号屏蔽字，解除对这两个信号的阻塞。

需要注意的是，sigprocmask 函数仅对当前进程的信号屏蔽字进行修改，并不影响其他进程的信号处理。

这些函数接口都是针对 头文件中定义的 sigset_t 类型的信号集进行操作。它们一般用于配合其他信号处理函数或系统调用（如 sigprocmask()）来设置或查询进程的信号屏蔽状态。需要注意的是，这些函数在不同的操作系统和平台上可能会有细微的差异，因此在使用时应查阅相关的文档和官方手册来了解具体的使用方式和兼容性。

4.8未处理信号集

实时信号和非实时信号在被屏蔽时的行为有所不同。

需要注意的是，如果实时信号的队列溢出，而处理函数尚未处理完所有排队的实时信号时，新到达的实时信号将被丢弃。因此，在实时信号的处理函数中，应当尽早处理队列中的实时信号，以避免队列溢出。

总结起来，如果非实时信号被屏蔽，只会保留一个未处理的实例。而实时信号在被屏蔽时会排队保留，并在解除屏蔽后按照到达的顺序进行处理。

五.消息队列

5.1消息队列特点

Linux 中的消息队列具有以下特点：

需要注意的是，Linux 的消息队列仅仅是 IPC（Inter-Process Communication，进程间通信）机制之一，还有其他的方式，如管道、共享内存等。选择合适的通信机制需要根据具体的需求和应用场景进行评估。

补充

独立于进程
没有文件名和文件描述符
IPC对象具有key和ID

5.2编程步骤

使用消息队列进行编程通常包含以下步骤：

需要注意的是，具体的编程步骤可能会因不同的编程语言、消息队列实现库和应用场景而有所差异。此外，还需了解所用消息队列的具体特性和相关的 API 文档，以便正确地使用和操作消息队列。

5.3函数接口

1.ftok（）

ftok 函数是 POSIX 标准中定义的一个函数，用于将给定的路径名和项目标识符生成一个唯一的键值，通常用于创建和关联 System V 消息队列、共享内存和信号量等 IPC 机制。

ftok 函数原型如下：

key_t ftok(const char *pathname, int proj_id);

• pathname：一个存在的文件的路径名。通常使用一个特定的文件作为路径名，以表明某个特定 IPC 对象和项目相关联。
• proj_id：一个非零的整数，用于区分不同的项目。需要保证在同一个 pathname 下，不同的 proj_id 生成的键值是唯一的。

ftok 函数返回一个 key_t 类型的键值。该键值在后续的 msgget、shmget、semget 等函数中用于标识和关联IPC对象。

需要注意的是，ftok 函数的键值生成是基于文件的 i-node 号和 proj_id 进行计算的。因此，当使用 ftok 生成键值时，需要确保 pathname 所指向的文件是存在的且不会轻易改变，否则可能导致生成的键值发生变化。

以下是一个示例使用 ftok 函数的代码片段：

#include 
#include 

int main() {
    // 生成一个键值
    key_t key = ftok("/tmp/myfile", 'A');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 使用生成的键值进行其他操作，比如创建消息队列、共享内存、信号量等

    return 0;
}

在这个示例中，我们将路径名设为 "/tmp/myfile"，proj_id 设置为 'A'，并使用 ftok 生成一个键值，然后可以将这个键值传递给其他 IPC 相关的函数使用。

总之，ftok 函数用于将路径名和项目标识符转换为一个唯一的键值，用于标识和关联 System V 消息队列、共享内存和信号量等 IPC 机制。

2.msgget（）

msgget 函数用于创建消息队列或获取已存在的消息队列的标识符。

函数原型如下：

#include 
#include 
#include 

int msgget(key_t key, int msgflg);

参数：

• key：一个键值，通常使用 ftok 函数生成。该键值用于唯一标识一个消息队列。
• msgflg：用于指定消息队列的权限和选项，可以通过按位或操作符 | 来设置多个选项。常用的选项包括：
  • IPC_CREAT：如果没有与给定 key 相关联的消息队列，则创建一个新的消息队列。
  • IPC_EXCL：与 IPC_CREAT 一起使用时，如果与给定 key 相关联的消息队列已经存在，则报错。

函数返回值：

• 成功时，返回消息队列的标识符（非负整数）。
• 失败时，返回 -1，并设置全局变量 errno 来指示错误原因。

以下是一个示例使用 msgget 的代码片段：

#include 
#include 
#include 
#include 
#include 

int main() {
    key_t key = ftok("/tmp/myfile", 'A');  // 生成键值
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    int msgflg = IPC_CREAT | 0666;  // 创建消息队列并设置权限

    // 创建或获取消息队列
    int msqid = msgget(key, msgflg);
    if (msqid == -1) {
        perror("msgget");
        return 1;
    }

    printf("成功创建或获取消息队列，标识符为: %d\n", msqid);

    return 0;
}

在这个示例中，我们调用 msgget 函数创建或获取一个消息队列，首先使用 ftok 生成键值，然后设置创建选项为 IPC_CREAT | 0666 来创建一个新的消息队列并设置权限。如果消息队列创建成功，msgget 函数将返回一个非负整数作为消息队列的标识符 msqid。如果创建失败，调用 perror 函数打印错误信息，并返回非零值。

需要注意的是，如果一个进程已经创建了一个与给定键值相关联的消息队列，其他进程可以通过相同的键值来获取该消息队列的标识符，从而实现进程间的通信。

总之，msgget 函数用于创建或获取消息队列标识符，用于进程间的消息通信。

3.msgsnd（）

msgsnd 函数用于向消息队列发送消息。

函数原型如下：

#include 
#include 
#include 

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

参数：

• msqid：消息队列的标识符，由 msgget 函数返回。
• msgp：指向要发送的消息的指针，通常是一个结构体指针，结构体定义应与消息队列中消息的结构匹配。
• msgsz：要发送的消息的大小（以字节为单位）。
• msgflg：发送消息的选项，可以通过按位或操作符 | 来设置多个选项，常用选项有：
  • IPC_NOWAIT：若消息队列已满，即时返回错误，而不是等待队列有空闲空间。
  • MSG_NOERROR：如果消息长度超过消息队列的最大字节数，则截断消息而不报错。

函数返回值：

• 成功时，返回 0。
• 失败时，返回 -1，并设置全局变量 errno 来指示错误原因。

以下是一个示例使用 msgsnd 的代码片段：

#include 
#include 
#include 
#include 
#include 
#include 

struct message {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key = ftok("/tmp/myfile", 'A');  // 生成键值
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    int msgflg = IPC_CREAT | 0666;  // 创建消息队列并设置权限

    // 创建或获取消息队列
    int msqid = msgget(key, msgflg);
    if (msqid == -1) {
        perror("msgget");
        return 1;
    }

    // 准备要发送的消息
    struct message msg;
    msg.mtype = 1;  // 消息类型，可以根据需要自定义
    strncpy(msg.mtext, "Hello, message queue!", sizeof(msg.mtext));

    // 发送消息
    int result = msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
    if (result == -1) {
        perror("msgsnd");
        return 1;
    }

    printf("成功发送消息到消息队列\n");

    return 0;
}

在这个示例中，我们调用 msgsnd 函数向消息队列发送消息。首先使用 ftok 生成键值，然后创建或获取了一个消息队列，并将准备好的消息（定义为一个结构体）发送到消息队列中。如果发送成功，msgsnd 函数将返回 0；如果发送失败，返回值为 -1，并通过调用 perror 函数打印错误信息。

总之，msgsnd 函数用于向消息队列发送消息，需要指定消息队列的标识符、要发送的消息内容和选项。

4.msgrcv（）

msgrcv 函数用于从消息队列接收消息。

函数原型如下：

#include 
#include 
#include 

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

参数：

• msqid：消息队列的标识符，由 msgget 函数返回。
• msgp：指向接收消息的缓冲区的指针，通常是一个结构体指针，结构体定义应与消息队列中消息的结构匹配。
• msgsz：接收缓冲区的大小（以字节为单位）。
• msgtyp：指定要接收的消息类型。设置为 0 表示接收队列中的第一条消息，设置为正数表示接收指定类型的消息，设置为负数表示接收小于或等于指定类型的最小数值的消息。
• msgflg：接收消息的选项，可以通过按位或操作符 | 来设置多个选项，常用选项有：
  • IPC_NOWAIT：若队列为空，即时返回错误，而不是等待队列有可用消息。

函数返回值：

• 成功时，返回实际接收到的消息的长度（以字节为单位）。
• 失败时，返回 -1，并设置全局变量 errno 来指示错误原因。

以下是一个示例使用 msgrcv 的代码片段：

#include 
#include 
#include 
#include 
#include 
#include 

struct message {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key = ftok("/tmp/myfile", 'A');  // 生成键值
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    int msgflg = IPC_CREAT | 0666;  // 创建消息队列并设置权限

    // 创建或获取消息队列
    int msqid = msgget(key, msgflg);
    if (msqid == -1) {
        perror("msgget");
        return 1;
    }

    // 准备接收消息的缓冲区
    struct message received_msg;

    // 接收消息
    ssize_t result = msgrcv(msqid, &received_msg, sizeof(received_msg.mtext), 1, 0);
    if (result == -1) {
        perror("msgrcv");
        return 1;
    }

    printf("成功接收消息：%s\n", received_msg.mtext);

    return 0;
}

在这个示例中，我们调用 msgrcv 函数从消息队列接收消息。首先使用 ftok 生成键值，然后创建或获取一个消息队列，并准备一个缓冲区用于接收消息。通过调用 msgrcv 函数，指定要接收的消息类型为 1，然后将接收到的消息存储到接收缓冲区中。如果接收成功，msgrcv 函数将返回接收到的消息的长度（以字节为单位）；如果接收失败，返回值为 -1，并通过调用 perror 函数打印错误信息。

总之，msgrcv 函数用于从消息队列中接收消息，需要指定消息队列的标识符、接收缓冲区的大小、要接收的消息类型和选项。

5.msgctl（）
msgctl 函数用于控制消息队列，包括对消息队列的删除、获取与修改等操作。

函数原型如下：

#include 
#include 
#include 

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

参数：

• msqid：消息队列的标识符，由 msgget 函数返回。
• cmd：控制操作的命令，可以是以下值之一：
  • IPC_RMID：私有的标识符被删除，该消息队列将被销毁。
  • IPC_SET：设置消息队列的属性，需要提供 buf 参数指向的 msqid_ds 结构体，用于存储需要修改的属性。
  • IPC_STAT：获取消息队列的属性，buf 参数指向的 msqid_ds 结构体将被填充为消息队列的当前属性值。
• buf：指向 msqid_ds 结构体的指针，用于存储或获取消息队列的属性。

函数返回值：

• 成功时，返回 0。
• 失败时，返回 -1，并设置全局变量 errno 来指示错误原因。

以下是一个示例使用 msgctl 的代码片段：

#include 
#include 
#include 
#include 
#include 

int main() {
    key_t key = ftok("/tmp/myfile", 'A');  // 生成键值
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    int msgflg = IPC_CREAT | 0666;  // 创建消息队列并设置权限

    // 创建或获取消息队列
    int msqid = msgget(key, msgflg);
    if (msqid == -1) {
        perror("msgget");
        return 1;
    }

    // 删除消息队列
    int result = msgctl(msqid, IPC_RMID, NULL);
    if (result == -1) {
        perror("msgctl");
        return 1;
    }

    printf("成功删除消息队列\n");

    return 0;
}

在这个示例中，我们调用 msgctl 函数删除一个消息队列。首先使用 ftok 生成键值，然后创建或获取一个消息队列，并指定要删除操作的命令为 IPC_RMID，通过调用 msgctl 函数来删除消息队列。如果删除成功，msgctl 函数将返回 0；如果删除失败，返回值为 -1，并通过调用 perror 函数打印错误信息。

总之，msgctl 函数用于对消息队列进行控制操作，可以删除消息队列、获取消息队列属性或修改消息队列属性。需要提供消息队列的标识符、控制操作的命令以及可选的参数 buf 来存储或获取属性。

5.4编程实战

msgsend.c

#include

#include

#include

#include

#include

#include

#include

#include 

struct msgsend

{

    long type; //第一个必须是long类型

    char text[1024];

};
int main(int argc, char const *argv[])

{

    //1.ftok产生唯一key值

    key_t key = ftok("/home/hq/demo/进程/a.txt", 'A');

    if (key < 0)

    {

        perror("key is err");

        return 0;

    }
    //2.创建或打开消息队列

    int msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666);

    //等于0报错证明已经创建过相同key的消息队列

    if (msgid