linux 进程间通信例程

嗯，用户想了解Linux进程间通信的例程，也就是IPC的常见方法以及示例代码。首先，我需要回忆一下Linux中进程间通信的主要方式有哪些。记得有管道、消息队列、共享内存、信号量、信号，还有Socket和文件等等。可能还有最新的方法，比如DBus，不过常见的应该是前面那些。
用户可能是开发者，或者刚开始学习Linux系统编程的学生，所以需要给出每种方法的简要说明和简单的代码示例。需要确保例子足够简单，容易理解，同时涵盖基本用法。可能用户需要这些例子来应用到实际项目中，或者为了面试、考试做准备。
接下来，我要分别整理每种IPC方法的要点。比如管道分为匿名管道和命名管道。匿名管道用于父子进程间通信，而命名管道可以在无关进程间使用。消息队列的话，可能需要用到msgget、msgsnd、msgrcv这些函数。共享内存涉及到shmget、shmat等，还要注意同步问题，这时候可能会用到信号量。信号量本身也是一个IPC机制，但通常用来同步其他IPC操作。信号的话，比如SIGUSR1这种自定义信号的处理。Socket虽然通常用于网络，但本地Unix域套接字也是一种IPC方式，效率较高。
然后，每个部分需要给出一个代码示例。例如匿名管道，可以写一个父进程创建管道，fork子进程，然后父写子读或者反过来。注意在代码中处理读写关闭的描述符，比如关闭不需要的端。命名管道的话，可能需要用mkfifo函数创建FIFO文件，然后分别写读写进程的代码。
消息队列的例子可能稍微复杂，需要定义消息结构体，使用msgget创建队列，msgsnd发送，msgrcv接收。注意使用IPC_EXCL等标志，以及权限设置。共享内存的例子需要创建共享内存段，附加到进程地址空间，然后写入和读取数据，最后分离和删除。这里要注意使用ftok生成key，以及shmctl的操作。
信号量可能需要使用semget、semop等函数，或者更简单的POSIX信号量，比如sem_open。不过系统V的信号量可能更传统一些，但代码可能会比较复杂，需要初始化信号量值，进行P/V操作。信号处理的话，需要注册信号处理函数，使用kill发送信号，注意可重入函数的问题。
Socket的例子可能需要使用socketpair或者AF_UNIX的套接字，展示如何建立连接，发送数据。另外，文件锁也是一种方式，比如使用flock或者fcntl来同步文件访问。
在组织内容时，应该先简要介绍每种方法的特点和适用场景，再给出示例代码。代码要简洁，不需要太多错误处理，但关键步骤要有注释。比如在共享内存的例子中，父进程和子进程的同步可能需要信号量或者等待，但为了简单可能暂时省略，或者提到需要注意同步问题。
还需要注意用户可能对某些函数不熟悉，所以可能需要解释关键函数的作用，比如msgget的作用是创建或获取消息队列。但可能用户只需要代码示例就能理解大致流程，所以注释可以简短。
另外，考虑用户可能需要编译这些例子，所以给出编译命令可能会有帮助，比如使用gcc编译时需要链接哪些库，不过大部分IPC函数在标准库中，可能不需要特别选项，除了例如-lrt 对于共享内存或信号量的某些函数。
可能还需要注意不同Unix-like系统的兼容性，但用户提到的是Linux，所以可以专注于Linux的实现。
总结一下，回答的结构应该是分点列出每种IPC方法，给出简介、适用场景和示例代码。代码需要展示基本的使用流程，如创建IPC对象、通信、清理资源。同时提醒需要注意的地方，比如同步、资源释放等。
现在需要检查是否有遗漏的IPC方法，比如内存映射文件（mmap）是否算共享内存的一部分？是的，共享内存通常使用shmget或者mmap来实现。可能例子中使用的是系统V的共享内存，但也可以提到mmap的方式。
此外，最新的方法比如DBus可能更适用于桌面环境下的进程通信，但用户可能只需要传统方法，所以可以暂时不提。
最后，确保每个例子都是正确的，比如管道的例子中，父进程关闭读端，子进程关闭写端，然后发送字符串。消息队列的例子中结构体要有mtype字段，发送和接收时指定类型。共享内存的例子可能需要同步机制，比如使用信号量，但例子中可以简单使用sleep来等待，虽然不严谨，但为了示例简短。
总之，整理这些内容后，就可以形成一个结构清晰、示例明确的回答，帮助用户理解Linux下的进程间通信方法。在 Linux 系统中，进程间通信（IPC）是不同进程交换数据的核心机制。以下是常见的 IPC 方法及其简单示例：

1. 管道（Pipe）
特点：单向通信，适用于父子进程或兄弟进程。示例：匿名管道实现父子进程通信。
#include <stdio.h>
#include <unistd.h>

int main() {
int fd[2];
char buf[20];
pipe(fd); // 创建管道

if (fork() == 0) { // 子进程读
close(fd[1]);
read(fd[0], buf, sizeof(buf));
printf("Child received: %s\n", buf);
} else { // 父进程写
close(fd[0]);
write(fd[1], "Hello from parent", 17);
}
return 0;
}
登录后复制

2. 命名管道（FIFO）
特点：通过文件系统路径标识，允许无关进程通信。步骤：

创建 FIFO 文件：mkfifo /tmp/myfifo
写进程代码：

#include <fcntl.h>
#include <stdio.h>

int main() {
    int fd = open("/tmp/myfifo", O_WRONLY);
    write(fd, "Hello FIFO!", 11);
    close(fd);
    return 0;
}
3. 读进程代码：

#include <fcntl.h>
#include <stdio.h>

int main() {
char buf[20];
int fd = open("/tmp/myfifo", O_RDONLY);
read(fd, buf, sizeof(buf));
printf("Received: %s\n", buf);
close(fd);
return 0;
}
登录后复制

3. 消息队列（Message Queue）
特点：结构化数据传输，通过唯一标识符（key）访问队列。示例：
#include <sys/msg.h>
#include <stdio.h>

struct msg_buf {
long mtype;
char data[100];
};

int main() {
key_t key = ftok("/tmp", 'A');
int msgid = msgget(key, IPC_CREAT | 0666);

if (fork() == 0) { // 子进程发送消息
struct msg_buf msg = {1, "Hello from child"};
msgsnd(msgid, &amp;msg, sizeof(msg.data), 0);
} else { // 父进程接收消息
struct msg_buf msg;
msgrcv(msgid, &amp;msg, sizeof(msg.data), 1, 0);
printf("Parent received: %s\n", msg.data);
msgctl(msgid, IPC_RMID, NULL); // 删除队列
}
return 0;
}
登录后复制

4. 共享内存（Shared Memory）
特点：高效的大数据共享，需配合信号量同步。示例：
#include <sys/shm.h>
#include <stdio.h>
#include <string.h>

int main() {
int shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT | 0666);
char *shm = shmat(shmid, NULL, 0);

if (fork() == 0) { // 子进程写
strcpy(shm, "Hello from child");
} else { // 父进程读
wait(NULL); // 等待子进程完成
printf("Parent read: %s\n", shm);
shmdt(shm);
shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
}
return 0;
}
登录后复制

5. 信号量（Semaphore）
特点：协调进程对共享资源的访问，避免竞态条件。示例（使用 System V 信号量）：
#include <sys/sem.h>
#include <stdio.h>

void P(int semid) { // 等待操作
struct sembuf op = {0, -1, 0};
semop(semid, &amp;op, 1);
}

void V(int semid) { // 通知操作
struct sembuf op = {0, 1, 0};
semop(semid, &amp;op, 1);
}

int main() {
int semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666);
semctl(semid, 0, SETVAL, 1); // 初始值为1

if (fork() == 0) {
P(semid);
printf("Child enters critical section\n");
sleep(1);
V(semid);
} else {
P(semid);
printf("Parent enters critical section\n");
sleep(1);
V(semid);
}
return 0;
}
登录后复制

6. 信号（Signal）
特点：异步通知机制，如 SIGINT、SIGUSR1 等。示例：父子进程通过信号通信。
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
printf("Received signal: %d\n", sig);
}

int main() {
signal(SIGUSR1, handler); // 注册信号处理函数

if (fork() == 0) { // 子进程发送信号
sleep(1);
kill(getppid(), SIGUSR1);
} else { // 父进程等待信号
pause(); // 挂起直到信号到达
}
return 0;
}
登录后复制

7. 套接字（Socket）
特点：支持网络和本地通信（如 Unix Domain Socket）。本地套接字示例：
// 服务端
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>

int main() {
int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr addr = {AF_UNIX, "/tmp/mysock"};
bind(sockfd, &amp;addr, sizeof(addr));
listen(sockfd, 5);

int client = accept(sockfd, NULL, NULL);
write(client, "Hello from server", 17);
close(client);
unlink("/tmp/mysock");
return 0;
}

// 客户端（部分代码）
int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
connect(sockfd, &amp;addr, sizeof(addr));
read(sockfd, buf, sizeof(buf));
登录后复制

总结

方法
适用场景
特点

管道
父子进程简单通信
单向，基于字节流

命名管道（FIFO）
无关进程通信
文件系统可见

消息队列
结构化数据传输
支持消息类型标记

共享内存
高效大数据共享
需同步机制（如信号量）

信号量
协调共享资源访问
解决竞态条件

信号
异步事件通知
轻量但功能有限

套接字
跨网络或本地复杂通信
灵活但开销较大

根据具体场景选择合适的方法（如实时性要求、数据量大小等），并注意同步和资源释放问题。