进程之间的数据交互（使用管道和套接字实现进程通信）

最新推荐文章于 2024-08-19 10:25:48 发布
最新推荐文章于 2024-08-19 10:25:48 发布
阅读量567 收藏 1
点赞数 1
分类专栏： C/C++ 文章标签： 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46190471/article/details/131681037
版权

本篇目录

进程通信的方法有哪些

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

  1. 管道（Pipe）：

    • 管道是一种基于文件描述符的通信方式，用于父子进程或具有共同祖先的进程之间的通信。
    • 管道可以使用无名管道（Unnamed Pipe）或命名管道（Named Pipe）实现。

  2. 消息队列（Message Queues）：

    • 消息队列是一种通过消息传递进行通信的机制，其中消息具有特定的格式和标识符。
    • 进程可以通过将消息放入队列中来发送消息，其他进程则可以从队列中接收消息。

  3. 共享内存（Shared Memory）：

    • 共享内存是一种进程间共享内存区域的通信方式，多个进程可以访问和修改相同的共享内存段。
    • 进程可以通过读写共享内存区域来实现数据的共享和传递。

  4. 信号量（Semaphores）：

    • 信号量是一种用于进程间互斥和同步的通信方式，可以用于保证临界资源的互斥访问和进程的同步执行。

  5. 套接字（Socket）：

    • 套接字是一种网络编程中常用的进程间通信方式，可用于不同主机之间的进程通信。
    • 套接字提供了一种可靠的、面向连接的通信机制，可以在客户端和服务器之间进行数据传输。

  6. 文件（File）：

    • 进程可以使用文件作为一种简单的通信方法，通过读写文件来实现进程间的数据交换。
    • 这种通信方式适用于多个进程需要共享访问的持久化数据。

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

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

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

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

  1. 首先，命令解析器（通常是bash shell）会接收到输入的ls命令。
  2. 命令解析器会解析命令，并确定要执行的程序文件的路径。对于ls命令来说，该路径通常是/bin/ls或/usr/bin/ls。
  3. 接下来，操作系统会加载并执行ls程序。
  4. ls程序开始执行后，它会与操作系统进行交互。它访问当前目录的文件系统，并获取该目录下的所有文件和子目录的信息。
  5. 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;
}

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

  1. 使用popen函数执行指定的命令，并打开命令输出管道。需要将your_command替换为实际的命令。
  2. 使用fgets函数从命令输出管道中逐行读取输出信息到缓冲区buffer中。
  3. 在每行输出信息的处理过程中，可以根据需要进行相应的操作，例如打印输出或做其他处理。
  4. 使用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() 函数的返回值有以下三种可能情况：

  1. 如果返回值是负数，表示创建子进程失败。
  2. 如果返回值是 0，表示当前代码正在运行的是子进程。
  3. 如果返回值大于 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时，它相当于一个服务器。

代码解读如下：

  1. 头文件包含部分：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

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

  1. 定义常量：
#define PORT 8888                      // 指定监听端口号
#define MAX_BUFFER_SIZE 1024           // 指定缓冲区最大大小
  1. 主函数部分：
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协议向服务器发送消息。

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

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

Jackey_Song_Odd
关注
专栏目录
进程之间的数据交换
weixin_45053545的博客
04-16 1507
进程之间的数据交换 1 通过multiprocessing中的Queue进行交流 1.1 创建队列 import multiprocessing # 创建一个消息队列 que = multiprocessing.Queue(5) print(que) #将数据存储进队列 for item in range(10): # que.put(item,True,2) que.pu...
day10-进程间数据交互及共享
weixin_33912638的博客
08-09 107
一、概述 　　之前我们讲述了进程之间的是通过进程中的Queue，来进行数据共享的，其实还有一种方式实现数据共享，那就是管道，pipe，以及数据共享manger。 二、数据通信 2.1、Pipe()函数 英文解释：ThePipe()function returns a pair of connection objects connected by a pipe which by defa...
【操作系统】7.进程之间是怎么协作的？
最新发布
weixin_69595694的博客
08-19 1490
是由代表共享资源的数据结构和一组过程（进行PV操作的函数）组成的管理程序（封装）。协调进程间的相互制约关系，使它们按照预期的方式执行的过程。直接相互制约关系（同步）：进程间的合作，比如管道通信。忙则等待：临界区已有进程，其它进程等待（阻塞状态）进程被阻塞的条件（原因）有多个，移入不同的条件队列。进程是资源分配的基本单位，各进程内存空间彼此独立。Swap指令（ EXCHANGE，XCHG指令）进入区：尝试进入临界区，成功则加锁（lock）退出区：解锁（unlock），唤醒其它阻塞进程。
简单进程间数据交互
weixin_43134049的博客
12-26 184
来源 from multiprocessing import Process, Queue # 导入Process和Queue import os, time, random def write(q): # 定义函数,接收Queue的实例参数 for v in range(10): print('Put %s to Queue' % v) q.put(v) # 添加数据到Queue time.sleep(1) def read(q):
day10-进程间数据交互
weixin_33911824的博客
08-07 119
一、概述 　　我们知道不同进程之间内存是不共享的，要想实现两个进程间的通信，咋办呢？我们用什么知识来解决呐？今天就来说说进程间的通信。 二、前戏 　　之前我们说了queue，这个是线程queue，它的主要目的是两个线程之间的数据，一个是生产者，一个是消费者的模型，而且你必须是线程。只能在这个主线程内的其他线程访问，出了这个进程，你就不能被访问了。 2.1、进程访问queue from...
进程、多进程、进程间数据交互、进程同步、进程池
qq_22599905的博客
09-05 135
多进程 启用多进程，可以解决python调用计算机CPU多核运算的问题 启动一个进程 import multiprocessing import time def run(name): time.sleep(2) print('hello',name) for i in range(10): p = multiprocessing.Process(target=ru...
Linux通过匿名管道进行进程间通信
09-15
这种方式适用于简单的父子进程通信，但对于更复杂的需求，如双向通信或多进程通信，可能需要考虑其他IPC机制，如套接字、消息队列或共享内存等。理解并熟练运用这些通信机制，对于开发高效、可靠的多进程应用至关...
命名管道及套接字通信相关资料
08-29
### 命名管道及套接字通信相关资料 #### 命名管道基础概念 命名管道（Named Pipes）作为一种进程间通信（Inter-Process Communication, IPC）机制，被广泛应用于Windows NT、Windows 2000、Windows 95以及Windows ...
jc.rar_进程的管道通信
09-14
同时，管道也常常与其他进程通信方式结合使用，如套接字、消息队列等，以构建更复杂、更灵活的系统架构。 总的来说，“jc.rar_进程的管道通信”这一主题为我们提供了一个深入学习进程间通信机制的机会，通过理解并...
Linux进程间通信：理解管道、套接字和信号
# 1. 引言 ### 1.1 问题的背景和重要性 ...本文旨在介绍Linux下的进程间通信机制，包括管道、套接字和信号等常用的通信方式。我们将详细讨论每种通信方式的原理、用法和适用场景，帮助读者理解并正确
qt使用QProcess实现父子进程通信,适用linux平台
10-27
在Linux中，这些接口被封装为POSIX套接字或Unix域套接字。 1. **创建子进程**：在Qt中，通过`QProcess::start()`函数可以启动一个新的进程。例如，我们可以调用`QProcess::start("childProc", QStringList{"arg1", ...
进程间交互
啃骨头的小蚂蚁
08-20 619
<br />所谓 IO 其实不过是与其他设备之间的数据交互。在 Linux 上这个概念或许会更加清楚一些。Linux 把所有设备都看作是一种文件，因此所有的 IO 都归结到对文件的数据交互。同样，与其他进程之间也存在着数据交互，这就是进程间交互。<br />为什么需要进程间交互呢？Qt 虽然是一个很庞大的库，但是也不能面面俱到。每个需求都提供一种解决方案是不现实的。比如操作系统提供了查看当前文件夹下所有文件的命令(Windows 下是 dir， Linux 下是 ls)，那么 Qt 就可以通过调
进程间通信的方式
weixin_51153209的博客
11-08 465
​ 进程是具有独立性的，进程之间在保持各自独立性时，可能会存在特定的协同工作的场景，比如一个进程要把数据交付给另一个进程进行处理，这种场景下就需要进程间通信。要实现进程间通信，操作系统就要设计适合系统的通信方式，然而进程是具有独立性的，要交互数据，成本非常高，因为一个进程是获取不到另一个进程的资源的，如果要实现进程间通信就必须让不同的进程可以看到同一份资源。 成功时返回0，失败时返回EOF pfd 包含两个元素的整形数组，用来保存文件描述符 pfd[0]用于读管道；pfd[1]用于写管道 无名管道的读写
进程之间的交互
qq_28134109的博客
07-12 1073
守护进程： 1，什么是守护进程？ 守护进程就是在父进程代码运行完毕后就结束的进程，本身就是一个进程 2，守护进程的使用场景， 在父进程的代码运行完毕之后就没有存在的意义了，就需要释放该进程 3，使用守护进程， from multiprocessing import Process def runing(参数1，...
进程的交互
CodeMyDream的专栏
09-05 644
Bionic能够使原生的应用程序来开始和其他的原生
操作系统：进程通信-进程之间的信息交换
hhhhxxn的博客
05-17 3088
知识总览： 进程是分配系统资源的单位（包括内存地址空间），因此各进程拥有的内存地址空间相互独立。如下图所示，进程1可以访问进程1的地址空间，进程2可以访问进程2的地址空间，但进程1不可以访问进程2的地址空间。 为了保证安全，一个进程不能直接访问另一个进程的地址空间。但是进程之间的信息交换又是必须实现的（例如：在QQ里看到一张有趣的表情包想要分享给微信好友）。为了保证进程间的安全通信，操作系统提供了一些方法： 共享存储 消息传递 管道通信 一、共享存储 操作系统为两个进程提供一块共享空间。两个进程对共享
进程间通信
qq_45325459的博客
04-05 760
进程通信简介管道 简介 why:为什么无法通信？ 每个进程都有自己的虚拟地址空间，访问的都是虚拟地址，进程间具有独立性，无法直接通信； 进程通信的原理：系统为进程提供公共传输媒介实现公共访问进而实现通信，根据通信需求有不同方式： 管道、共享内存、消息队列、信号量 管道 1.1 定义 把从一个进程连接到另一个进程的一个数据流 通信原理：多个进程只要能够访问同一块内核中的缓冲区（管道）就能实现通信 1.2 特性 半双工通信<可选性单向通信> 提供字节流传输服务：有序的，基于连接的，可靠的传
进程间的交互
JosephXQ的博客
06-24 2144
进程间的交互分为竞争关系、协作关系。1、竞争关系由于计算机内资源有限，或者说某几个进程必须共享某些资源与变量，这时候就不可避免的会出现竞争，进程的相互竞争就会穿死锁和饥饿问题，饥饿问题已解释。死锁问题是指一组进程如果都获得了部分资源，还想要得到其他进程占用的资源，最终所有进程都将陷入死锁，即都在等待，每个进程都不会先放手自己占有的资源。进程互斥：若干进程在使用共享资源的时候，其他进程必须等待正在使...
进程通信之进程池，队列
松鼠豪的坚果
08-08 239
 进程的定义作用已经在其他文章中讲过，这里谈一谈进程之间的通信问题。 一： 队列（Queue） 可以使用multiprocessing模块的Queue实现多进程之间的数据传递 下面是一个具体的实现栗子，演示一下Queue的工作原理： from multiprocessing import Queue # 创建容量为3的队列 q = Queue(3) q.put('message1') q...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jackey_Song_Odd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值