本篇目录

进程通信的方法有哪些
C语言使用管道实现进程通信
- 使用管道进行实时通信
C语言使用套接字进行进程通信

进程通信的方法有哪些

进程通信是指在操作系统中，不同进程之间进行数据传递、信息共享和协调工作的方法。以下是常见的进程通信方法：

管道（Pipe）：
- 管道是一种基于文件描述符的通信方式，用于父子进程或具有共同祖先的进程之间的通信。
- 管道可以使用无名管道（Unnamed Pipe）或命名管道（Named Pipe）实现。
消息队列（Message Queues）：
- 消息队列是一种通过消息传递进行通信的机制，其中消息具有特定的格式和标识符。
- 进程可以通过将消息放入队列中来发送消息，其他进程则可以从队列中接收消息。
共享内存（Shared Memory）：
- 共享内存是一种进程间共享内存区域的通信方式，多个进程可以访问和修改相同的共享内存段。
- 进程可以通过读写共享内存区域来实现数据的共享和传递。
信号量（Semaphores）：
- 信号量是一种用于进程间互斥和同步的通信方式，可以用于保证临界资源的互斥访问和进程的同步执行。
套接字（Socket）：
- 套接字是一种网络编程中常用的进程间通信方式，可用于不同主机之间的进程通信。
- 套接字提供了一种可靠的、面向连接的通信机制，可以在客户端和服务器之间进行数据传输。
文件（File）：
- 进程可以使用文件作为一种简单的通信方法，通过读写文件来实现进程间的数据交换。
- 这种通信方式适用于多个进程需要共享访问的持久化数据。

这些是常见的进程通信方法，每种方法都有其特点和适用场景。根据具体的需求和情况，选择合适的进程通信方法可以有效地实现进程间的数据传递和协作。

本文主要介绍管道进程通信和套接字进程通信。

C语言使用管道实现进程通信

当在Linux命令行下输入ls并按下回车时，操作系统会执行以下步骤：

首先，命令解析器（通常是bash shell）会接收到输入的ls命令。
命令解析器会解析命令，并确定要执行的程序文件的路径。对于ls命令来说，该路径通常是/bin/ls或/usr/bin/ls。
接下来，操作系统会加载并执行ls程序。
ls程序开始执行后，它会与操作系统进行交互。它访问当前目录的文件系统，并获取该目录下的所有文件和子目录的信息。
ls程序将获取到的文件和目录信息输出到命令行窗口上，供用户查看。

总结来说，当在Linux命令行下输入ls并按下回车时，操作系统会加载并执行ls程序，然后ls程序会获取当前目录的文件和目录信息，并将其输出到命令行窗口上供用户查看。在 Windows 系统上，也是类似的道理。

命令的本质就是一个可执行的程序，在命令行下执行命令时，操作系统就会为该程序创建一个进程。当我们在命令行下输入命令，操作系统为我们执行命令，此时操作系统会在当前目录下寻找该命令的可执行文件，如果没有找到，则去环境变量下寻找。当程序（命令）被执行时，程序的输出都会显示在命令行下。

以下是一个进程通信的C语言例子：在下面这个 C 语言代码中，popen("command", "r"); 函数会调用另外一个程序，这里的 command 就是一个可执行程序的名字，当该程序被调用时，操作系统会为它创建进程。而下面的代码编译后运行时，也是一个进程，该进程在运行时，会创建对应 command 的进程，随后 command 的进程的输出信息会通过管道被它的调用进程读取，并将信息输出。

#include <stdio.h>

int main() {
    FILE *fp;
    char buffer[256];

    // 执行命令并打开命令输出管道
    fp = popen("your_command", "r");

    if (fp == NULL) {
        printf("无法执行命令\n");
        return 1;
    }

    // 逐行读取命令输出信息
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        // 处理每行输出
        // 示例：打印输出
        printf("%s", buffer);
    }

    // 关闭命令输出管道
    pclose(fp);

    return 0;
}

在上面的示例中，关键步骤如下：

使用popen函数执行指定的命令，并打开命令输出管道。需要将your_command替换为实际的命令。
使用fgets函数从命令输出管道中逐行读取输出信息到缓冲区buffer中。
在每行输出信息的处理过程中，可以根据需要进行相应的操作，例如打印输出或做其他处理。
使用pclose函数关闭命令输出管道。

例如将 command 替换成 ls (Linux下) 或者 dir (Windows下) 运行：

在这里插入图片描述
这样就实现了进程通信，ls 或者 dir 的输出信息传输给调用它们的进程。

在上面的代码中，调用了 ls，调用进程和被调用进程是父子进程的关系。管道通信只能在具有父子关系或共同祖先的进程之间进行。如果你需要在没有父子关系的两个独立进程之间进行实时通信，可能需要使用其他IPC机制，比如命名管道、消息队列、共享内存等。

当我们使用集成的开发环境(IDE Integrated Development Environment) IntelliJ IDEA 去做Java 开发的时候，IntelliJ IDEA 做的就是调用 javac 去编译 java 的源代码，当源代码有错误的时候，IntelliJ IDEA 会把错误信息显示在图形界面上，IntelliJ IDEA 的源代码中就用到了进程通信。它调用了 javac，此时 javac 就是它的子进程，然后 javac 把错误信息通过管道传给它的调用进程。

在这里插入图片描述

使用管道进行实时通信

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

int main() {
    int pipefd[2];
    pid_t pid;
    
    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    // 创建子进程
    pid = fork();
    
    if (pid > 0) {
        // 父进程
        
        // 关闭写端
        close(pipefd[1]);
        
        // 从读端读取数据
        char buffer[1024];
        ssize_t bytesRead = read(pipefd[0], buffer, sizeof(buffer));
        printf("父进程接收到消息：%.*s\n", (int)bytesRead, buffer);
        
        // 等待子进程结束
        wait(NULL);
        
        // 关闭读端
        close(pipefd[0]);
    }
    else if (pid == 0) {
        // 子进程
        
        // 关闭读端
        close(pipefd[0]);
        
        // 向写端写入数据
        char message[] = "Hello, parent process!";
        write(pipefd[1], message, sizeof(message));
        
        // 关闭写端
        close(pipefd[1]);
    }
    else {
        // fork失败
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    return 0;
}

这段代码是一个使用管道进行父子进程间通信的示例。

首先，在 main 函数中创建了一个整型数组 pipefd 来存储管道的文件描述符，这个数组有两个元素，分别表示管道的读端和写端。

接下来调用 pipe() 函数创建管道。如果函数返回值为 -1，则说明创建管道失败，程序将打印错误信息并退出。

然后通过 fork() 函数创建子进程。如果返回值大于 0，说明是在父进程中；如果返回值等于 0，说明是在子进程中。

对于父进程，它关闭了管道的写端 pipefd[1]，然后通过 read() 函数从管道的读端 pipefd[0] 中读取数据，将读取到的数据存储在缓冲区 buffer 中，并打印输出。

接着调用 wait(NULL) 函数等待子进程结束。

最后，父进程关闭管道的读端 pipefd[0]，完成操作。

对于子进程，它关闭了管道的读端 pipefd[0]，然后通过 write() 函数向管道的写端 pipefd[1] 中写入数据，该数据为字符数组 message 中的内容。

最后，子进程关闭管道的写端 pipefd[1]，完成操作。

需要注意的是，代码中使用了一些系统调用函数如 close()、read()、write()、wait()，需要包含相应的头文件 <unistd.h> 和 <sys/wait.h>。此外，还包含了 <stdio.h> 和 <stdlib.h> 头文件用于提供标准输入输出和一些基本函数。

pid = fork(); 这行代码的作用是通过调用 fork() 函数创建一个子进程。

在调用 fork() 函数时，会复制当前进程（称为父进程），并创建一个新的子进程。这个新的子进程与父进程几乎完全相同，包括代码、数据和打开的文件等。

具体而言，fork() 函数的返回值有以下三种可能情况：

如果返回值是负数，表示创建子进程失败。
如果返回值是 0，表示当前代码正在运行的是子进程。
如果返回值大于 0，表示当前代码正在运行的是父进程，返回值是新创建的子进程的进程ID。

根据返回值的不同，代码中的 if 语句可以分别对父进程和子进程做出不同的处理，实现父子进程之间的分支逻辑。

通常情况下，在 fork() 后的代码中会使用条件判断来区分父进程和子进程的执行路径，从而实现不同的操作或任务。

C语言使用套接字进行进程通信

代码一：

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

#define PORT 8888
#define MAX_BUFFER_SIZE 1024

int main() {
    int sockfd, newsockfd;
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t addrLen;
    char buffer[MAX_BUFFER_SIZE];

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

    // 设置服务器地址信息
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定套接字到指定端口
    if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("bind");
        exit(1);
    }

    // 监听连接请求
    if (listen(sockfd, 10) < 0) {
        perror("listen");
        exit(1);
    }

    printf("Waiting for incoming connections...\n");

    // 接受连接请求
    addrLen = sizeof(clientAddr);
    newsockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &addrLen);
    if (newsockfd < 0) {
        perror("accept");
        exit(1);
    }

    // 接收消息
    if (recv(newsockfd, buffer, MAX_BUFFER_SIZE, 0) < 0) {
        perror("recv");
        exit(1);
    }

    printf("Message received from client: %s\n", buffer);

    close(newsockfd);
    close(sockfd);

    return 0;
}

代码二：

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

#define PORT 8888

int main() {
    int sockfd;
    struct sockaddr_in serverAddr;
    char buffer[1024];

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

    // 设置服务器地址信息
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    // 连接到服务器
    if (connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("connect");
        exit(1);
    }

    printf("Enter a message: ");
    fgets(buffer, 1024, stdin);

    // 发送消息到服务器
    if (send(sockfd, buffer, strlen(buffer), 0) < 0) {
        perror("send");
        exit(1);
    }

    printf("Message sent to the server: %s\n", buffer);

    close(sockfd);

    return 0;
}

编译运行：先编译运行代码一，再编译运行代码二。

在这里插入图片描述使用套接字，不仅可以实现本机的进程通信，也可以实现不同主机之间的进程通信。涉及计算机网络相关知识。

代码一解读：
这段代码是进程A的代码，它创建一个套接字并监听指定端口，等待来自进程B的连接请求。一旦连接建立，进程A将接收来自进程B发送的消息，并在控制台输出。当运行进程A时，它相当于一个服务器。

代码解读如下：

头文件包含部分：

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

这些头文件提供了套接字编程所需的函数、结构和常量。

定义常量：

#define PORT 8888                      // 指定监听端口号
#define MAX_BUFFER_SIZE 1024           // 指定缓冲区最大大小

主函数部分：

int main() {
    int sockfd, newsockfd;
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t addrLen;
    char buffer[MAX_BUFFER_SIZE];

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

通过 socket 函数创建一个套接字，AF_INET 表示使用 IPv4 地址族，SOCK_STREAM 表示使用 TCP 传输协议。如果创建失败，会打印错误信息并退出程序。

    // 设置服务器地址信息
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

设置服务器地址信息，包括地址族、端口号和 IP 地址。INADDR_ANY 表示绑定到本地的所有可用网络接口。

    // 绑定套接字到指定端口
    if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("bind");
        exit(1);
    }

将套接字与指定的端口号进行绑定，如果绑定失败则打印错误信息并退出。

    // 监听连接请求
    if (listen(sockfd, 10) < 0) {
        perror("listen");
        exit(1);
    }

开始监听连接请求，指定最大允许排队等待连接的请求数量为 10。如果监听失败则打印错误信息并退出。

    printf("Waiting for incoming connections...\n");

    // 接受连接请求
    addrLen = sizeof(clientAddr);
    newsockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &addrLen);
    if (newsockfd < 0) {
        perror("accept");
        exit(1);
    }

输出提示信息，并调用 accept 函数接受来自客户端的连接请求。如果接受失败则打印错误信息并退出。

    // 接收消息
    if (recv(newsockfd, buffer, MAX_BUFFER_SIZE, 0) < 0) {
        perror("recv");
        exit(1);
    }

使用 recv 函数从客户端接收消息，将消息存储在缓冲区 buffer 中。如果接收失败则打印错误信息并退出。

    printf("Message received from client: %s\n", buffer);

    close(newsockfd);
    close(sockfd);

    return 0;
}

将接收到的消息输出到控制台，并关闭套接字和新的套接字描述符，释放资源。最后返回 0 表示程序正常结束。

代码二解读：
代码二是一个简单的客户端程序，用于通过TCP/IP协议向服务器发送消息。

首先，代码包含了一些系统库头文件，如stdio.h、stdlib.h等，这些头文件提供了所需的函数和类型定义。
定义了常量PORT，指定服务器的端口号为8888。
主函数开始后，创建一个套接字sockfd，使用socket函数，该套接字用于与服务器进行通信。如果创建失败，则打印错误信息并退出程序。
设置服务器地址信息，结构体变量serverAddr是存储服务器地址的结构体，设置其中的成员变量sin_family表示地址家族为AF_INET（IPv4），sin_port表示端口号，使用htons函数将主机字节序转换为网络字节序，sin_addr.s_addr表示服务器的IP地址，使用宏INADDR_ANY表示可以使用任意可用的IP地址。
使用connect函数将套接字连接到指定的服务器地址，如果连接失败，则打印错误信息并退出程序。
打印提示信息，要求用户输入消息内容。
使用fgets函数从标准输入中读取用户输入的消息，保存在buffer数组中。
使用send函数将消息发送给服务器，参数分别为套接字描述符 sockfd、消息内容 buffer、消息长度 strlen(buffer)，如果发送失败，则打印错误信息并退出程序。
打印已发送的消息内容。
关闭套接字，使用close函数关闭套接字描述符。
程序执行完毕，返回0作为退出状态码。

总体上，这段代码实现了与服务器建立连接，并向服务器发送消息的功能。