C++多进程之间通讯

已于 2024-08-09 11:27:33 修改
阅读量914 收藏 10
点赞数 25
文章标签： c++ 算法 linux
于 2024-08-08 11:09:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xutaoshuaiqi/article/details/141018487
版权

在 C++ 中，线程和进程是有区别的：

  • 进程：是操作系统分配资源的基本单位，包括代码、数据和系统资源。每个进程都有自己独立的地址空间，因此进程之间不能直接访问彼此的内存。

  • 线程：是操作系统能够进行运算调度的最小单位。线程是进程的一个实体，是进程中的实际运行单位，线程拥有自己的堆栈和局部变量。线程之间可以直接访问彼此的内存。

在 C++ 中，std::thread 用于创建和管理线程，而不是进程。如果你需要创建进程，你可以使用操作系统提供的 API，例如在 Unix 系统上使用 fork() 函数，或者在 Windows 系统上使用 CreateProcess() 函数。

1、创建一个子进程：fork()

fork() 函数是一个标准的系统调用，用于在 Unix 和类 Unix 系统中创建新的进程。

以下是一个简单的例子，展示了如何使用 fork() 函数：

#include <iostream>
#include <unistd.h>

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

    if (pid < 0) {
        // fork() 失败
        std::cerr << "fork() failed\n";
        return 1;
    } else if (pid == 0) {
        // 子进程
        std::cout << "This is the child process, pid: " << getpid() << "\n";
    } else {
        // 父进程
        std::cout << "This is the parent process, pid: " << getpid() << ", child pid: " << pid << "\n";
    }

    return 0;
}

输出为：

xo@shahis1:~/demo$ vim fork_test.cpp
xo@shahis1:~/demo$ g++ fork_test.cpp -o fork_test
xo@shahis1:~/demo$ ./fork_test 
This is the parent process, pid: 1821956, child pid: 1821957
This is the child process, pid: 1821957

在这个例子中，fork() 函数会创建一个新的进程，并返回两次：一次在父进程中返回子进程的 PID，一次在子进程中返回 0。你可以使用这个返回值来区分父进程和子进程，并执行不同的操作。

如果你在使用 fork() 函数时遇到了问题，你可能需要检查以下几点：

  1. 编译器和操作系统：确保你的代码在支持 fork() 函数的系统上编译和运行。fork() 函数是 Unix 和类 Unix 系统的标准库函数，不支持 Windows。

  2. 权限：确保你有足够的权限来创建新的进程。在某些系统上，你可能需要管理员权限才能使用 fork() 函数。

  3. 错误处理：确保你正确处理了 fork() 函数的错误情况。在上面的例子中，我们检查了 pid 的值是否小于 0，这表示 fork() 函数调用失败。

一个进程操作公共容器的例子： 

#include <iostream>
#include <unistd.h>
#include <vector>
#include <mutex>
#include <sys/wait.h>

// 模拟一个容器
struct Container {
    int value;
};

// 全局变量
std::vector<Container> containers;
std::mutex mtx;

// 进程A创建若干db container
void processA() {
    std::cout << &containers << std::endl;
    for (int i = 0; i < 10; ++i) {
        Container c;
        c.value = i;
        containers.push_back(c);
    }
    std::cout << "copy after " << &containers << std::endl;
    std::cout << containers.size() << std::endl;
}

// 进程B尝试读取共享container
void processB() {
    sleep(1);
    std::cout << &containers << std::endl;
    std::lock_guard<std::mutex> lock(mtx);

    for (const auto& c : containers) {
        std::cout << "Container value: " << c.value << "\n";
    }
    std::cout << containers.size() << std::endl;
}

int main() {
    // 1. 客户端和服务端 initialization
    // 这里可以添加你的初始化代码

    // 2. 由进程A创建若干db container
    pid_t pidA = fork();
    if (pidA == 0) {
        // 子进程A
        processA();
        return 0;
    } else if (pidA > 0) {
        // 父进程
        std::cout << "Parent process: " << getpid() << "\n";
        std::cout << "Child process A ID: " << pidA << "\n";

        // 3. 进程B尝试读取共享container
        pid_t pidB = fork();
        if (pidB == 0) {
            // 子进程B
            processB();
            return 0;
        } else if (pidB > 0) {
            // 父进程
            std::cout << "Child process B ID: " << pidB << "\n";

            // 4. 测试同步原语，在A中进行加锁操作，测试进程B是否被阻塞
            // 这里已经通过 std::lock_guard 实现了加锁操作

            // 5. 销毁退出测试
            // 等待子进程A和B结束
            int statusA, statusB;
            waitpid(pidA, &statusA, 0);
            waitpid(pidB, &statusB, 0);

            // 打印子进程的退出状态
            std::cout << "Child process A exited with status: " << statusA << "\n";
            std::cout << "Child process B exited with status: " << statusB << "\n";

            // 这里可以添加你的销毁代码
        } else {
            std::cerr << "Failed to create process B" << "\n";
        }
    } else {
        std::cerr << "Failed to create process A" << "\n";
    }

    return 0;
}

输出为：

Parent process: 1971493
Child process A ID: 1971494
Child process B ID: 1971495
0x55a86ad2f280
copy after 0x55a86ad2f280
10
0x55a86ad2f280
0
Child process A exited with status: 0
Child process B exited with status: 0

在这个示例中，我们使用了 fork() 函数来创建两个子进程，分别模拟进程A和进程B。进程A创建若干个容器，进程B尝试读取这些容器。我们使用 std::mutex 来实现同步原语，并使用 std::lock_guard 来自动管理锁的生命周期。waitpid 函数用于等待子进程结束，并获取子进程的退出状态。这是一种常见的资源清理方法，确保子进程在结束后释放相关资源。

注意哈！从结果看出我们代码的目的并没有实现，这是为啥呢？

在 Unix 系统中，fork 创建的子进程与父进程之间的资源共享情况取决于具体的资源类型。以下是关于 fork 创建的子进程与父进程之间资源共享的一些关键点：

  1. 代码段和数据段：代码段和数据段是共享的。子进程和父进程共享相同的代码段和数据段，因此它们可以访问相同的内存地址。

  2. 堆区：堆区是私有的。子进程和父进程有各自独立的堆区。堆区中的内存分配（例如使用 malloc 或 new）在子进程中不会影响父进程的堆区。

  3. 栈区：栈区是私有的。子进程和父进程有各自独立的栈区。栈区中的内存分配（例如函数调用）在子进程中不会影响父进程的栈区。

  4. 打开的文件描述符：打开的文件描述符是共享的。子进程和父进程共享相同的文件描述符表，因此它们可以访问相同的文件。

  5. 信号处理：信号处理是共享的。子进程和父进程共享相同的信号处理程序。

  6. 进程 ID 和父进程 ID：子进程和父进程有各自独立的进程 ID 和父进程 ID。

  7. 进程状态：子进程和父进程有各自独立的进程状态。例如，父进程和子进程可以有不同的运行状态（运行、暂停、停止等）。

总结来说，fork 创建的子进程与父进程之间的资源共享取决于具体的资源类型。代码段和数据段、打开的文件描述符、信号处理和进程状态是共享的，而堆区和栈区是私有的。

我们再看个例子：

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

int global_var = 10;

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

    if (pid == 0) {
        // 子进程
        printf("子进程 ID: %d, 全局变量值: %d\n", getpid(), global_var);
        global_var = 20;
        printf("子进程修改后的全局变量值: %d\n", global_var);
	    printf("global_var_addr = %p\n", &global_var);
    } else if (pid > 0) {
        // 父进程
        printf("父进程 ID: %d, 全局变量值: %d\n", getpid(), global_var);
        sleep(1);  // 确保子进程先执行完毕
        printf("父进程修改后的全局变量值: %d\n", global_var);
	    printf("global_var_addr = %p\n", &global_var);
    } else {
        // fork 失败
        perror("fork 失败");
    }

    return 0;
}

输出结果为：

父进程 ID: 1978290, 全局变量值: 10
子进程 ID: 1978291, 全局变量值: 10
子进程修改后的全局变量值: 20
global_var_addr = 0x55830dff6010
父进程修改后的全局变量值: 10
global_var_addr = 0x55830dff6010

 发现了没有！地址虽然是那个地址，但是值不一样。这是为啥呢？

在 Unix 系统中，fork 创建的子进程与父进程之间的全局变量共享情况取决于具体的资源类型。以下是关于 fork 创建的子进程与父进程之间全局变量共享的一些关键点：

  1. 全局变量的内存位置：全局变量在内存中的位置是共享的。子进程和父进程共享相同的全局变量内存地址。这意味着任何对全局变量的修改，无论是在父进程还是子进程中，都会影响到共享的内存位置。

  2. 全局变量的值：全局变量的值在 fork 时是共享的。子进程和父进程在 fork 时会有相同的全局变量值。任何对全局变量的修改都会影响到共享的内存位置，从而影响到另一个进程的全局变量值。

  3. 写时复制（Copy-on-Write）机制：在某些情况下，操作系统可能会使用写时复制（Copy-on-Write, COW）机制来优化内存使用。当子进程试图修改全局变量时，操作系统会自动为子进程创建一个全局变量的私有副本，以避免父进程和子进程共享同一块内存。

需要注意的是，写时复制机制并不总是启用的，具体取决于操作系统的实现和配置。

总结来说，fork 创建的子进程与父进程之间的全局变量共享是通过共享内存位置和值来实现的。任何对全局变量的修改都会影响到共享的内存位置，并且可能会触发写时复制机制来创建私有副本。

2、pipe管道通信

管道是一种进程间通信（IPC）机制，它允许两个进程之间传递数据。管道的文件描述符是一个数组，包含两个元素：pipefd[0] 是读端，pipefd[1] 是写端。在使用管道时，通常需要关闭不需要的文件描述符，以避免混淆和资源泄漏。

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>

void childProcess(int pipefd[]) {
    // 关闭不需要的文件描述符
    close(pipefd[0]); // 关闭读端

    // 向管道写入数据
    const char* message = "Hello from child process!";
    write(pipefd[1], message, strlen(message) + 1);

    // 关闭写端
    close(pipefd[1]);
}

void parentProcess(int pipefd[]) {
    // 关闭不需要的文件描述符
    close(pipefd[1]); // 关闭写端

    // 从管道读取数据
    char buffer[100];
    int bytesRead = read(pipefd[0], buffer, sizeof(buffer) - 1);
    if (bytesRead > 0) {
        buffer[bytesRead] = '\0'; // 添加字符串终止符
        std::cout << "Message from child process: " << buffer << std::endl;
    }

    // 关闭读端
    close(pipefd[0]);
}

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        childProcess(pipefd);
    } else {
        // 父进程
        parentProcess(pipefd);

        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
    }

    return 0;
}

输出结果为：

Message from child process: Hello from child process!

如果你需要通过管道传递多个数据，可以通过多次写入和读取操作来实现。以下是一个示例，展示了如何通过管道传递多个数据：

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
#include <cstring>

void childProcess(int pipefd[]) {
    // 关闭不需要的文件描述符
    close(pipefd[0]); // 关闭读端

    // 向管道写入多个消息
    const char* messages[] = {"Hello", "from", "child", "process!"};
    for (const char* message : messages) {
        write(pipefd[1], message, strlen(message) + 1);
        // 添加延时，确保子进程有足够的时间向管道写入消息
	    sleep(1);
    }

    // 关闭写端
    close(pipefd[1]);
}

void parentProcess(int pipefd[]) {
    // 关闭不需要的文件描述符
    close(pipefd[1]); // 关闭写端

    // 从管道读取多个消息
    char buffer[100];
    while (true) {
        int bytesRead = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if (bytesRead > 0) {
            buffer[bytesRead] = '\0'; // 添加字符串终止符
            std::cout << "Message from child process: " << buffer << std::endl;
        } else {
            break; // 读取到文件结束符，退出循环
        }
    }

    // 关闭读端
    close(pipefd[0]);
}

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        childProcess(pipefd);
    } else {
        // 父进程
        parentProcess(pipefd);

        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
    }

    return 0;
}

结果输出为·：

Message from child process: Hello
Message from child process: from
Message from child process: child
Message from child process: process!

以下是代码的详细解释：

  1. 创建管道：在main函数中，使用pipe函数创建一个管道，并将管道的文件描述符存储在pipefd数组中。

  2. 创建子进程：使用fork函数创建一个子进程。如果fork函数调用成功，父进程会返回子进程的PID，子进程会返回0。

  3. 子进程：在子进程中，关闭不需要的管道端，然后向管道写入多个消息。需要注意的是这里必须sleep，否则只会输出一个信息Hello。

  4. 父进程：在父进程中，关闭不需要的管道端，然后从管道读取消息。每次读取一个消息后，都会添加一个字符串终止符'\0'。如果读取到的字节数小于0，表示读取到文件结束符，此时退出循环。

  5. 等待子进程结束：在父进程中，使用waitpid函数等待子进程结束，并获取子进程的退出状态。

还有一种方法就是一次性输入一个拼接好的字符串，然后再父进程分割。

管道的最大容量通常由操作系统的文件系统和内核参数决定。以下是一些常见的限制因素：

  1. 文件系统限制：不同的文件系统有不同的最大文件大小限制。例如，在某些文件系统中，单个文件的最大大小可能为4GB或更大。

  2. 内核参数：内核参数fs.pipe-max-size定义了管道的最大容量。在Linux系统中，可以使用以下命令查看当前的最大管道大小：

sysctl fs.pipe-max-size

在某些系统中，管道的最大容量可能被限制为65536字节（64KB）。

        3.实际限制：

        1）内存限制：如果管道的数据量过大，可能会导致内存不足，从而影响系统性能。

        2）读写速度：如果读取和写入管道的速度过快，可能会导致数据丢失或其他问题。

在实际应用中，管道的使用应该避免大量数据的写入和读取，以避免可能的性能问题。如果需要传输大量数据，建议使用其他方式，如文件、套接字或内存映射文件。

大爱吾神彦
关注
  • 25
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++多线程多进程.doc
08-09
C++多线程多进程概述 C++多线程多进程是指在同一个程序中使用多个线程或进程来提高程序的并发度和响应时间。多线程多进程技术可以让程序在同一时间同时执行多条任务，从而提高程序的效率和响应速度。 进程是资源...
C++进程间通信 消息队列
Warren++的博客
05-29 874
C++进程间通信 消息队列
C++进程间通信的多种方式及实现
qq_43119867的博客
05-06 7401
多进程通信
C++ 多进程多线程间通信
最新发布
wy749929317的博客
07-05 980
请注意，这里的互斥锁是在全局命名空间中创建的（通过前缀"Global\\"），这意味着它可以在系统范围内的任何进程中访问。这是必需的，因为我们的目标是让多个不同的进程能够识别并访问同一个互斥锁。请注意，我们使用了全局命名的信号量（通过前缀Global\），这意味着信号量在整个系统中都是可见的，可以被任何进程访问。特点：它是最快的进程间通信方式，避免了数据的拷贝，但共享内存需要解决并发访问和同步问题，常用的同步机制包括互斥锁（Mutexes）、信号量（Semaphores）和事件（Events）等。
C++ 进程间通信
热门推荐
qthello
05-31 2万+
一，C++ 常用进程间通信 管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe)：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。 信号(Signal)：信号...
C++ 进程间通信详解
肖邦的夜曲的专栏
06-22 1万+
一，C++ 常用进程间通信 管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe)：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。 信号(Signal)：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身;Linu.
【C++】开源：Boost进程间通信库InterProcess配置使用
DevFrank的博客
12-04 1088
Boost进程间通信库InterProcess配置使用
C++进程间通信
L_qingting的博客
07-10 3092
多进程是指在一个程序中同时运行多个独立的进程，每个进程都有自己的独立的内存空间和执行环境。进程间通信是指不同进程之间进行数据交换和共享资源的方式。
socket进程间通讯.rar
06-30
在这个“socket进程间通讯.rar”压缩包中，我们有两个核心文件：cppserver.cpp和cppclient.cpp，它们分别代表了一个简单的C++服务器和客户端程序，利用socket进行通信。下面我们将深入探讨C++中的socket编程及其在多...
RCF—用于C++的进程间通讯
08-22
RCF，全称为Remote Call Framework，是一个专门为C++设计的高效、可靠的进程间通信（IPC）框架。这个框架使得在不同的C++进程中进行数据交换变得简单而高效，它支持多种通信协议，包括TCP/IP、UDP、命名管道和共享...
C++进程通讯源码
04-15
在IT领域，尤其是在系统编程中，进程通信（Process Communication）是一项关键的技术，它允许不同的进程之间交换数据，协同工作。本资源"**C++进程通讯源码**"着重于使用C++实现这一功能，其中涉及到了父进程、管道...
C++共享内存进程间通信 demo
05-10
C++共享内存进程间通信 FileMapping用于进程间快速通信
各种多进程之间的通信实例
01-17
这是一个多进程通信的程序，有一个主进程和各种类型的子进程进行通信。
RCF-一个很好的进程间通信库
04-26
RCF is a portable C++ interprocess communication framework, using native C++ features to provide a new and simplified approach to writing distributed C++ software. RCF builds on the time honored concept of using interface declarations to specify remotely available functionality. Over the years there have been a number of well-known efforts building on that concept, from the venerable stalwarts of CORBA and DCOM, to modern day sequels such as Java RMI, .NET Remoting, WCF, WS-*, and so on. These frameworks all share a fundamental flaw, though: they use interfaces as a veneer for what is fundamentally an object-oriented view of distributed systems. RCF imposes no object model at all on remote interactions, and represents an interface-oriented view of distributed systems. RCF interfaces and data contracts are defined in standard C++ code, and not locked down to an elaborate object model. As such, RCF provides a simpler and more coherent programming model, than the aforementioned approaches. The RCF User Guide is intended as a guide in using RCF to write real-world distributed C++ software. Network programming is a notoriously difficult subject, but this guide will demonstrate how RCF lets you quickly and reliably construct robust, real-world networked applications.
Win32进程间通信实例(使用共享内存)
06-22
使用共享内存实现Win32进程之间的通信实例,程序中用到了Win32程序设计中常用到的semaphore, mutex等机制,老鸟请忽略.有问题交流请与本人E-mail联系, apt_kappa@sina.com
c++进程间通信程序
03-24
此代码为c++进程间通信的一个完整实例，代码编译后就可以运行，通过这个实例，可以掌握c++进程间的通信知识
11进程间通讯_共享内存
11-25
共享内存是一种在多进程之间实现高效通信的方法，它允许不同的进程直接读写同一块内存空间，从而极大地提高了数据交换的速度。在Windows系统中，Visual Studio 2013 Update 5及其更高版本提供了对进程间通信（IPC）...
C++进程间通信的十一种方法
神棍之路
12-27 4672
转载： https://www.cnblogs.com/swunield/articles/3893250.html 进程通常被定义为一个正在运行的程序的实例，它由两个部分组成： 一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方 另一个是地址空间，它包含所有的可执行模块或DLL模块的代码和数据。它还包含动态分配的空间。如线程堆栈和堆分配空间。每个进程被赋予它自...
RCF—用于C++的进程间通讯（1）
快乐菜鸟
05-17 9314
导言RCF（Remote Call Framework，远程调用框架）是一个C++的框架。这个框架用来为实现C++程序进程间调用提供一个简单和一致（consistent）的方法。这个框架基于强类型的C/S接口概念，类似于用户所熟悉的CORBA，DCOM这样的中间件。然而，因为RCF只应用于C++，所以可以充分利用C++特性，从而提供一个以相对简单和整洁的方式实现进程间调用。这是RCF库
c++ 多进程之间的通讯
05-26
在 C++ 中，可以使用多种方式实现进程间通信，包括管道、共享内存、消息队列、信号量等。 其中，管道是一种基于文件描述符的通信方式，可以通过 fork() 函数创建子进程，然后通过管道进行通信。 共享内存是一种特殊的内存区域，在多个进程之间共享，可以通过 mmap() 函数映射到进程的地址空间中，从而实现进程间通信。 消息队列是一种以消息为单位的通信方式，可以让不同进程之间通过发送和接收消息来进行通信，可以使用 System V 消息队列或 POSIX 消息队列。 信号量是一种用于进程同步和互斥的机制，可以通过 semget() 函数获取信号量标识符，再通过 semop() 函数进行操作。 在选择进程间通信方式时，需要根据具体的场景和需求来选择最合适的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值