进程间通信方式介绍

**进程间通信方式介绍**

在多进程环境中，进程之间需要进行通信，以实现数据交换、资源共享等功能。进程间通信是指不同进程之间的信息交换和数据传递。在 Unix/Linux 等操作系统中，提供了多种进程间通信方式来满足不同应用需求。

**1.管道通信**

管道是一种最基本的进程间通信方式，它允许两个进程在同一个终端上进行通信。管道是通过创建一个特殊的文件来实现的，这个文件被称为管道文件（pipe）。管道通信有两种形式：无名管道和命名管道。

**1.1 无名管道**

无名管道是一种匿名的管道，它不需要在进程之间进行显式创建。它是通过在父进程中使用 `pipe()` 函数来创建的，然后将其传递给子进程。在子进程中，通过 `read()` 和 `write()` 函数来读取和写入管道中的数据。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int fd[2]; // 管道描述符 if (pipe(fd) == -1) {
 perror("pipe");
 exit(EXIT_FAILURE);
 }

 pid_t pid = fork();

 if (pid ==0) { // 子进程 close(fd[0]); // 关闭读端 char buffer[10];
 write(fd[1], "Hello, world!",13); // 写入管道 close(fd[1]);
 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 close(fd[1]); // 关闭写端 char buffer[10];
 read(fd[0], buffer,13); //读取管道 printf("%s
", buffer);
 close(fd[0]);
 }

 return0;
}

**1.2 命名管道**

命名管道是通过在进程之间创建一个特殊的文件来实现的，这个文件被称为命名管道（named pipe）。它允许两个进程在不同的终端上进行通信。命名管道的创建和使用与无名管道类似，但需要在进程之间进行显式创建。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

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

 // 创建命名管道 if (mkfifo(fifo,0666) == -1) {
 perror("mkfifo");
 exit(EXIT_FAILURE);
 }

 pid_t pid = fork();

 if (pid ==0) { // 子进程 char buffer[10];
 write(fifo, "Hello, world!",13); // 写入命名管道 close(fifo);
 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 char buffer[10];
 read(fifo, buffer,13); //读取命名管道 printf("%s
", buffer);
 close(fifo);

 // 删除命名管道 if (unlink(fifo) == -1) {
 perror("unlink");
 exit(EXIT_FAILURE);
 }
 }

 return0;
}

**2.信号通信**

信号是进程之间的一种特殊的消息，它允许一个进程向另一个进程发送信号。信号可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 pid_t pid = fork();

 if (pid ==0) { // 子进程 sleep(5); // 等待5秒 kill(getppid(), SIGUSR1); // 发送信号给父进程 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 while (1) {
 pause(); // 等待信号 printf("Received signal
");
 }
 }

 return0;
}

**3.共享内存通信**

共享内存是进程之间的一种特殊的内存区域，它允许多个进程共享同一块内存。共享内存可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int *shared_memory = (int *)malloc(sizeof(int));

 pid_t pid = fork();

 if (pid ==0) { // 子进程 *shared_memory =10; // 写入共享内存 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 sleep(5); // 等待5秒 printf("%d
", *shared_memory); //读取共享内存 free(shared_memory);
 }

 return0;
}

**4.套接字通信**

套接字是进程之间的一种特殊的连接，它允许多个进程通过网络进行通信。套接字可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int server_fd, client_fd;
 struct sockaddr_in server_addr, client_addr;

 // 创建服务器套接字 if (socketpair(AF_UNIX, SOCK_STREAM,0, &server_fd) == -1) {
 perror("socketpair");
 exit(EXIT_FAILURE);
 }

 pid_t pid = fork();

 if (pid ==0) { // 子进程 close(server_fd); // 关闭服务器套接字 char buffer[10];
 read(client_fd, buffer,13); //读取客户端数据 printf("%s
", buffer);
 close(client_fd);
 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 close(client_fd); // 关闭客户端套接字 char buffer[10];
 write(server_fd, "Hello, world!",13); // 写入服务器数据 close(server_fd);
 }

 return0;
}

**5.消息队列通信**

消息队列是进程之间的一种特殊的缓冲区，它允许多个进程通过消息队列进行通信。消息队列可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int queue_id = msgget(1234,0666 | IPC_CREAT); // 创建消息队列 pid_t pid = fork();

 if (pid ==0) { // 子进程 char buffer[10];
 sprintf(buffer, "Hello, world!"); // 写入消息队列 msgsnd(queue_id, &buffer, strlen(buffer), IPC_NOWAIT);
 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 sleep(5); // 等待5秒 char buffer[10];
 msgrcv(queue_id, &buffer,13,0, IPC_NOWAIT); //读取消息队列 printf("%s
", buffer);
 }

 return0;
}

**6.信号量通信**

信号量是进程之间的一种特殊的计数器，它允许多个进程通过信号量进行通信。信号量可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int sem_id = semget(1234,1,0666 | IPC_CREAT); // 创建信号量 pid_t pid = fork();

 if (pid ==0) { // 子进程 sleep(5); // 等待5秒 sem_wait(sem_id); // 等待信号量 printf("Received signal
");
 sem_post(sem_id); // 发送信号量 exit(EXIT_SUCCESS);
 } else if (pid >0) { // 父进程 sleep(5); // 等待5秒 sem_wait(sem_id); // 等待信号量 printf("Received signal
");
 sem_post(sem_id); // 发送信号量 }

 return0;
}

**7.共享内存通信**

共享内存是进程之间的一种特殊的内存区域，它允许多个进程共享同一块内存。共享内存可以用于实现进程间通信、资源共享等功能。

c#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
 int *shared_memory = (int *)malloc(sizeof(int));

 pid_t pid = fork();

 if (pid ==0