进程间通信（Inter-Process Communication，IPC）是操作系统中一个重要的概念，它允许不同进程之间进行数据交换。在C语言编程中，实现进程间通信有多种方法，以下将介绍五种实用的框架以及实战技巧。
1. 消息队列（Message Queues）
简介：
消息队列是一种先进先出（FIFO）的数据结构，允许进程之间通过消息进行通信。在Linux系统中，可以使用mq_open、mq_send和mq_receive等函数来实现。
实战技巧：
- 使用
mq_setattr设置消息队列的属性，如最大消息大小、优先级等。 - 使用
mq_getattr获取消息队列的属性。
代码示例：
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
mqd_t mq;
mq_attr attr;
char message[100];
// 创建消息队列
mq = mq_open("/my_queue", O_CREAT | O_WRONLY, 0666, &attr);
if (mq == (mqd_t)-1) {
perror("mq_open");
exit(1);
}
// 发送消息
snprintf(message, sizeof(message), "Hello, IPC!");
if (mq_send(mq, message, strlen(message) + 1, 0) == -1) {
perror("mq_send");
exit(1);
}
// 关闭消息队列
mq_close(mq);
return 0;
}
2. 信号量（Semaphores）
简介：
信号量是一种同步机制，用于控制对共享资源的访问。在Linux系统中，可以使用sem_open、sem_wait和sem_post等函数来实现。
实战技巧：
- 使用
sem_init初始化信号量。 - 使用
sem_destroy销毁信号量。
代码示例：
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
sem_t sem;
int rc;
// 打开信号量
rc = sem_open("/my_semaphore", O_CREAT, 0644, 1);
if (rc == -1) {
perror("sem_open");
exit(1);
}
// 等待信号量
sem_wait(&sem);
// 信号量操作
printf("Semaphore acquired.\n");
// 释放信号量
sem_post(&sem);
// 关闭信号量
sem_close(&sem);
return 0;
}
3. 共享内存（Shared Memory）
简介：
共享内存允许多个进程共享同一块内存区域。在Linux系统中，可以使用mmap、mprotect和munmap等函数来实现。
实战技巧：
- 使用
fcntl设置共享内存的权限。 - 使用
msync同步共享内存。
代码示例：
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define SHM_SIZE 1024
int main() {
int fd;
char *shm;
// 打开共享内存对象
fd = shm_open("/my_shared_memory", O_CREAT | O_RDWR, 0644);
if (fd == -1) {
perror("shm_open");
exit(1);
}
// 设置共享内存大小
ftruncate(fd, SHM_SIZE);
// 映射共享内存
shm = mmap(0, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (shm == MAP_FAILED) {
perror("mmap");
exit(1);
}
// 使用共享内存
strcpy(shm, "Hello, Shared Memory!");
// 解除映射
munmap(shm, SHM_SIZE);
// 关闭共享内存对象
close(fd);
return 0;
}
4. 管道（Pipes）
简介：
管道是一种简单的IPC机制，允许父子进程之间进行通信。在C语言中，可以使用pipe函数创建管道，并使用read和write函数进行读写操作。
实战技巧：
- 使用
fork创建子进程。 - 使用
dup2将文件描述符复制到标准输入/输出。
代码示例：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
int pipefd[2];
pid_t cpid;
// 创建管道
if (pipe(pipefd) == -1) {
perror("pipe");
exit(EXIT_FAILURE);
}
// 创建子进程
cpid = fork();
if (cpid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}
if (cpid == 0) { // 子进程
// 关闭管道的读端
close(pipefd[0]);
// 将管道的写端复制到标准输出
dup2(pipefd[1], STDOUT_FILENO);
// 执行命令
execlp("echo", "echo", "Hello, IPC!", (char *)NULL);
perror("execlp");
exit(EXIT_FAILURE);
} else {
// 父进程
// 关闭管道的写端
close(pipefd[1]);
// 从管道读取数据
char buf[10];
read(pipefd[0], buf, sizeof(buf));
printf("Received: %s\n", buf);
// 等待子进程结束
wait(NULL);
}
return 0;
}
5. 套接字（Sockets）
简介：
套接字是一种通用的网络通信机制，可以用于进程间通信。在C语言中，可以使用socket、bind、listen、accept和connect等函数来实现。
实战技巧：
- 使用
select、poll或epoll进行非阻塞I/O操作。 - 使用
getaddrinfo获取服务器地址信息。
代码示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main() {
int sockfd;
struct sockaddr_in servaddr;
// 创建套接字
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
perror("socket");
exit(EXIT_FAILURE);
}
// 设置服务器地址信息
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(8080);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
// 连接服务器
if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
perror("connect");
exit(EXIT_FAILURE);
}
// 发送数据
char message[] = "Hello, IPC!";
write(sockfd, message, strlen(message));
// 关闭套接字
close(sockfd);
return 0;
}
通过以上五种框架，你可以轻松实现C语言进程间通信。希望本文能帮助你更好地理解进程间通信的概念和方法。