进程间通信的7种方式

最新推荐文章于 2025-06-21 20:55:11 发布
最新推荐文章于 2025-06-21 20:55:11 发布
阅读量2k 收藏 34
点赞数 19
CC 4.0 BY-SA版权
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74186706/article/details/146849268

1. 信号（Signals）

原理：信号是 Linux 中用于进程间通信的异步通知机制，用于向进程传达系统事件（如中断请求、程序异常等）或特定进程的通知。每个信号对应特定事件，进程可注册信号处理函数来响应信号。比如，SIGINT 信号通常由用户按下 Ctrl + C 产生，用于中断前台进程；SIGTERM 用于正常终止进程。
案例：程序运行时，用户希望中断程序，可发送 SIGINT 信号。
代码示例（C 语言）：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// 信号处理函数
void signal_handler(int signal_num) {
    printf("Received signal: %d\n", signal_num);
}

int main() {
    // 注册SIGINT信号的处理函数
    signal(SIGINT, signal_handler); 
    while (1) {
        sleep(1);
        printf("Program is running...\n");
    }
    return 0;
}

 运行程序后，按下 Ctrl + C ，进程捕获 SIGINT 信号，执行信号处理函数打印信息。

2. 消息队列（Message Queue）

原理：内核中消息的链表，以消息为单位存储和传输数据，由消息队列标识符标识。进程可按特定规则向队列添加或读取消息，还能对消息指定类型，接收方可按需获取特定类型消息，克服信号信息少、管道数据格式受限等不足。
案例：一个日志记录程序和主程序通信，主程序将不同级别的日志消息（如错误、警告、信息）按类型发送到消息队列，日志记录程序从队列读取对应类型消息进行记录。
代码示例（C 语言）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

// 定义消息结构
struct msgbuf {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key;
    int msgid;
    struct msgbuf message;

    // 生成唯一键值
    key = ftok(".", 'a'); 
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // 创建消息队列
    msgid = msgget(key, 0666 | IPC_CREAT); 
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // 填充消息
    message.mtype = 1; 
    strcpy(message.mtext, "Hello from sender"); 

    // 发送消息
    if (msgsnd(msgid, &message, sizeof(message.mtext), 0) == -1) {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }
    printf("Message sent successfully\n");

    // 接收消息
    if (msgrcv(msgid, &message, sizeof(message.mtext), 1, 0) == -1) {
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }
    printf("Received message: %s\n", message.mtext);

    // 删除消息队列
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }
    return 0;
}

 上述代码创建消息队列，发送消息后再接收消息，最后删除队列。

3. 共享内存（Shared Memory）

原理：映射一段能被多个进程访问的内存区域，由一个进程创建，其他进程可将其映射到自身地址空间。进程能直接读写共享内存，无需在内核和用户空间多次拷贝数据，通信效率高，但需同步机制（如信号量）防止竞态条件。
案例：多个数据处理进程需共享原始数据，一个进程将数据读入共享内存，其他进程直接从共享内存读取数据进行处理。
代码示例（C 语言）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/wait.h>

#define SHM_SIZE 1024

int main() {
    key_t key;
    int shmid;
    char *shm;
    pid_t cpid;

    // 生成唯一键值
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // 创建共享内存段
    shmid = shmget(key, SHM_SIZE, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // 将共享内存段连接到进程地址空间
    shm = shmat(shmid, NULL, 0);
    if (shm == (char *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (cpid == 0) {
        // 子进程向共享内存写入数据
        strcpy(shm, "Hello from child");
        // 分离共享内存
        if (shmdt(shm) == -1) {
            perror("shmdt");
            exit(EXIT_FAILURE);
        }
        exit(EXIT_SUCCESS);
    } else {
        // 等待子进程结束
        wait(NULL);

        // 找到原有数据的末尾位置
        char *end = shm + strlen(shm);

        // 追加新数据
        strcpy(end, " and more data from parent");

        // 父进程从共享内存读取数据
        printf("Received from shared memory: %s\n", shm);

        // 分离共享内存
        if (shmdt(shm) == -1) {
            perror("shmdt");
            exit(EXIT_FAILURE);
        }

        // 删除共享内存段
        if (shmctl(shmid, IPC_RMID, NULL) == -1) {
            perror("shmctl");
            exit(EXIT_FAILURE);
        }
    }
    return 0;
}

父子进程通过共享内存进行数据交互。

4. 管道（Pipe）

原理：分为匿名管道和命名管道。匿名管道是存在于内存中的临时通信机制，用于有亲缘关系进程（如父子进程）间的单向数据传输，若要双向通信需两个管道；命名管道（FIFO）是特殊文件，在文件系统中有路径名，可用于不相关进程间通信。管道实质是内核缓冲区，进程以先进先出方式存取数据。
案例：父进程创建匿名管道，向管道写入数据，子进程从管道读取数据。或不同进程通过命名管道实现数据传输。
代码示例（C 语言，匿名管道）：

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <stdlib.h>

int main() {
    int pipefd[2];
    char buffer[100];

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

    pid_t cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (cpid == 0) {
        // 子进程关闭写端，读取数据
        close(pipefd[1]); 
        ssize_t num_bytes = read(pipefd[0], buffer, sizeof(buffer));
        if (num_bytes == -1) {
            perror("read");
            exit(EXIT_FAILURE);
        }
        printf("Child received: %.*s\n", (int)num_bytes, buffer);
        close(pipefd[0]);
    } else {
        // 父进程关闭读端，写入数据
        close(pipefd[0]); 
        const char *message = "Hello from parent";
        if (write(pipefd[1], message, strlen(message)) == -1) {
            perror("write");
            exit(EXIT_FAILURE);
        }
        close(pipefd[1]);
        wait(NULL);
    }
    return 0;
}

 此代码实现父子进程通过匿名管道通信，父进程写数据，子进程读数据。

5. 信号量（Semaphore）

原理：本质是计数器，用于控制多个进程对共享资源的访问。进程访问共享资源前需执行 wait 操作（信号量值减 1 ），访问后执行 post 操作（信号量值加 1 ） 。信号量值大于 0 时资源可用，为 0 时资源被占用。常作为进程间及同一进程内不同线程间的同步手段。
案例：多个进程要访问同一文件，用信号量控制，保证同一时刻只有一个进程能写入文件，避免数据混乱。
代码示例（C 语言，基于 POSIX 信号量）：

 

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

#define N 5
sem_t sem;

// 线程函数
void *thread_function(void *arg) {
    int num = *(int *)arg;
    // 等待信号量
    sem_wait(&sem); 
    printf("Thread %d is accessing the shared resource\n", num);
    // 模拟访问共享资源操作
    sleep(1); 
    printf("Thread %d is done accessing the shared resource\n", num);
    // 释放信号量
    sem_post(&sem); 
    return NULL;
}

int main() {
    pthread_t threads[N];
    int args[N];

    // 初始化信号量
    if (sem_init(&sem, 0, 1) == -1) {
        perror("sem_init");
        exit(EXIT_FAILURE);
    }

    for (int i = 0; i < N; i++) {
        args[i] = i + 1;
        if (pthread_create(&threads[i], NULL, thread_function, &args[i]) != 0) {
            perror("pthread_create");
            exit(EXIT_FAILURE);
        }
    }

    for (int i = 0; i < N; i++) {
        if (pthread_join(threads[i], NULL) != 0) {
            perror("pthread_join");
            exit(EXIT_FAILURE);
        }
    }

    // 销毁信号量
    if (sem_destroy(&sem) == -1) {
        perror("sem_destroy");
        exit(EXIT_FAILURE);
    }
    return 0;
}

上述代码创建多个线程，用信号量保证同一时刻只有一个线程访问共享资源。

 

6. 套接字（Socket）

原理：可用于不同主机进程间通信，也适用于同一主机不同进程通信。它提供了一种网络编程接口，通过创建套接字，绑定地址，监听连接（服务器端），发起连接（客户端）等操作，实现进程间数据传输。基于不同传输协议（如 TCP、UDP ）有不同特性，TCP 提供可靠、面向连接的字节流服务，UDP 提供无连接、不可靠的数据报服务。
案例：客户端 - 服务器模式的网络应用，如 Web 服务器与浏览器之间通过套接字通信，浏览器发送 HTTP 请求，服务器接收请求并返回网页数据。
代码示例（C 语言，TCP 客户端 - 服务器简单示例）：
服务器端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};

    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定地址
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 监听连接
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 接受连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    // 接收数据
    read(new_socket, buffer, BUFFER_SIZE);
    printf("Received: %s\n", buffer);

    // 发送数据
    const char *response = "Hello from server";
    send(new_socket, response, strlen(response), 0);

    close(new_socket);
    close(server_fd);
    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};

    // 创建套接字
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 将IP地址转换为网络字节序
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        exit(EXIT_FAILURE);
    }

    // 连接服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("connect");
        exit(EXIT_FAILURE);
    }

    // 发送数据
    const char *message = "Hello from client";
    send(sock, message, strlen(message), 0);

    // 接收数据
    read(sock, buffer, BUFFER_SIZE);
    printf("Received: %s\n", buffer);

    close(sock);
    return 0;
}

服务器端监听端口，接受连接并收发数据；客户端连接服务器并进行数据交互。

7. 命名管道（Named Pipe，FIFO）

原理：特殊类型文件，在文件系统中有实际路径名，允许不同进程通过读写这个文件来实现通信，可用于有亲缘关系或无亲缘关系的进程间通信。与匿名管道相比，它的生命周期独立于创建进程，可长期存在于文件系统中供多个进程使用。
案例：在一个日志监控系统中，日志生成进程将日志信息写入命名管道，日志分析进程从命名管道中读取日志信息进行分析处理。
代码示例（C 语言）：
写进程代码：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define FIFO_PATH "/tmp/my_fifo"

int main() {
    int fd;
    char message[100] = "Hello from writer";

    // 创建命名管道（若不存在）
    if (mkfifo(FIFO_PATH, 0666) < 0 && errno != EEXIST) {
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }

    // 打开命名管道用于写入
    fd = open(FIFO_PATH, O_WRONLY);
    if (fd < 0) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 写入数据
    if (write(fd, message, strlen(message)) < 0) {
        perror("write");
        exit(EXIT_FAILURE);
    }

    close(fd);
    return 0;
}

读进程代码：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define FIFO_PATH "/tmp/my_fifo"

int main() {
    int fd;
    char buffer[100];

    // 打开命名管道用于读取
    fd = open(FIFO_PATH, O_RDONLY);
    if (fd < 0) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 读取数据
    ssize_t num_bytes = read(fd, buffer, sizeof(buffer));
    if (num_bytes < 0) {
        perror("read");
        exit(EXIT_FAILURE);
    }
    buffer[num_bytes] = '\

https://github.com/0voice

进程间通信的方式
Minor的Java技术博客
06-26 557
进程通常需要与其它进程进行协作完成工作任务，他们之间需要通信已到达信息交互的需求，进程的用户空间都是私有的，而内核空间是共享的，所以进程间通信是基于内核的通信技术进行数据传递。...
操作系统-进程间的四种通信（共享内存、消息队列、信号、管道）
weixin_64612849的博客
06-17 1602
操作系统-进程间的通信-共享内存-消息队列-信号-管道
进程间通信、线程间通信
最新发布
2401_86968032的博客
06-21 690
进程间通行（Inter-Process Communication， IPC）和线程间通信（Thread Communication）的方式不完全相同，因为进程和线程的运行环境和特性不同。1、共享变量（Shard Variables）2、消息队列（Message Queue）4、信号量（Semaphore）进程间通信与线程间通信的异同。6、套接字（Socket）进程间通信（IPC）方式。5、信号（Signal）进程间通信、线程间通信。5、事件（Event）6、队列（Queue）1、管道（Pipe）
进程之间究竟有哪些通信方式？
weixin_43226231的博客
08-28 1548
有一次面试的时候，被问到进程之间有哪些通信方式，不过由于之前没深入思考且整理过，说的并不好。想必大家也都知道进程有哪些通信方式，可是我猜很多人都是靠着”背“来记忆的，所以今天的这篇文章，讲给大家详细着讲解他们是如何通信的，让大家尽量能够理解他们之间的区别、优缺点等，这样的话，以后面试官让你举例子，你也能够顺手拈来。 1、管道 我们来看一条Linux的语句 netstat -tulnp |...
【资料】linux进程间通信的方式
weixin_30687587的博客
10-19 399
【资料】linux进程间通信的方式 # 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 # 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 # 信号量( semophore ) ： 信号...
【Unix编程】进程间通信（IPC）
dbbaq24022的专栏
04-21 2724
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 一、管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 ...
进程间通信方式
记录各种Bug解决案例及日常学习内容
08-04 727
管道：速度慢，容量有限，只有父子进程能通讯；FIFO：任何进程间都能通讯，但速度慢；消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题；共享内存：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题；信号：有入门版和高级版两种，区别在于入门版注重动作，高级版可以传递消息。只有在父子进程或者是共享内存中，才可以发送字符串消息；信号量：不能传递复杂消息，只能用来同步。......
Python中的进程间通信
12-20
以下是几种常见的Python进程间通信方式： 1. **信号量（Semaphore）**：信号量是一个整型变量，用于控制对共享资源的访问。当进程想要访问资源时，它会尝试获取信号量，如果信号量可用，则进程可以继续，否则会被...
进程间通信的七种方法实战演示！值得收藏！
十年饮冰，难凉热血，保持热爱，奔赴星海！
09-21 2280
线程和进程间的通讯（Inter-Process Communication, IPC）是操作系统中的一个重要概念，用于实现不同进程或同一进程中的不同线程之间的数据交换和协调。以下是几个常见的进程间通信的方式：管道、消息队列、共享内存、信号、套接字、信号量、文件映射
linux-linux进程间通信方式汇总.zip
02-26
为了实现进程间的协作，就需要一种有效的方式来传递信息，这就是进程间通信的目的。 1. **管道（Pipe）**：管道是一种半双工的通信方式，数据只能单向流动。它将两个进程连接起来，形成一个临时的数据通道。管道...
《Linux系统编程、网络编程》第7章 进程间通信（本机IPC）
06-12
本文将深入探讨“《Linux系统编程、网络编程》第7章 进程间通信（本机IPC）”所涵盖的知识点，帮助读者理解和掌握进程间通信（IPC）的基本原理和实现方式。 首先，我们要理解为什么需要进程通信。在多任务操作系统...
用户进程间通信主要哪几种方式？
如是我闻
05-02 2562
（1）管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 （2）命名管道（named pipe）：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。 （3）信号（Signal）：信
Linux下进程通信的八种方法：
10-27 553
Linux下进程通信的八种方法：管道(pipe)，命名管道(FIFO)，内存映射(mapped memeory)，消息队列(message queue)，共享内存(shared memory)，信号量(semaphore)，信号(signal)，套接字(Socket).(1) 管道（pipe）：管道允许一个进程和另一个与它有共同祖先的进程之间进行通信；(2) 命名管道（FIFO）：类似于管道，但是
9.进程间通信的方式有哪些？各自的优缺点及应用选择？
热门推荐
的博客
08-08 1万+
1、进程间通讯方式有：管道，信号，信号量，消息队列，共享内存，套接字共六种 2、管道：管道分为有名管道和无名管道，其中无名管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用，一般用于两个不同进程之间的通信。有名管道也是一种半双工的通信方式，但它允许无亲缘关系进程间的通信。 3、信号：信号是一种比较复杂的通信方式，信号产生的条件：按键、硬件异常、进程调用kill函数...
进程间的通信方式有哪些？
weixin_43595755的博客
12-17 6024
进程间通信常见方式如下： 管道 FIFO 消息队列 信号量 共享内存 UNXI域套接字 套接字（Socket） 管道 管道是一种古老的IPC通信形式。 它的特点： 1.它是半双工的，具有固定的读端和写端； 2.它只能用于父子进程或者兄弟进程之间的进程的通信； 3.它可以看成是一种特殊的文件，对于它的读写也可以使用普通的 read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。 命名管道 FIFO 可以在无关的进程之间交换数据，与无名管道不同； FIFO 有路径名与之
进程间的几种通信方式
qq_39939541的博客
07-09 1420
不同的信号有不同的含义和处理方式，操作系统提供了一些默认的信号处理函数，但也允许进程自定义信号处理函数来实现特定的功能。父进程收到信号后，可以根据信号的类型来判断子进程的状态，并做出相应的处理。消息队列是一种进程间通信的机制，用于在不同进程之间传递数据。套接字（socket）是一种用于进程间通信的机制，它提供了一种标准的网络通信接口，使得不同计算机上的进程可以通过网络进行通信。1、可以进行不同计算机间的通信：套接字可以在不同计算机上的进程之间进行通信，使得分布在网络中的进程可以互相发送和接收数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值