【Linux】基于匿名管道通信实现的简易进程池

于 2024-07-28 17:49:40 发布
阅读量326 收藏 6
点赞数 10
分类专栏： Linux 文章标签： linux c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76606232/article/details/140752842
版权

 本文仅作为对于匿名管道通信的练习和进程池的初识，对于进程池的深度学习还请阅读《Linux高性能服务器编程》。

目录

一、进程池的概念

二、使用匿名管道实现进程池的注意事项：

1.1、主函数逻辑

1.2、父进程创建进程池并对子进程进行分流 

1.3、在每个子进程中将管道的读端重定向到标准输入流（0）的原因：

2、子进程在何时退出？ 

三、基于匿名管道通信实现的简易进程池完整代码

一、进程池的概念

  1. 定义：进程池是一种技术应用，它由资源进程和管理进程组成。资源进程是预先创建好的空闲进程，用于处理分配给它们的任务。管理进程则负责创建资源进程、分配任务给空闲的资源进程，并在任务完成后回收这些资源进程。

  2. 作用：进程池的主要作用是优化资源管理和提高系统效率。通过预先创建一定数量的进程并放入池中，当有任务需要执行时，可以直接从池中取出空闲进程来处理，而无需每次都创建新的进程。这种方式避免了频繁创建和销毁进程所带来的开销，节省了系统资源，并降低了操作系统的调度难度。

  3. 交互手段：管理进程与资源进程之间的交互是通过各种通信机制实现的，如IPC（进程间通信）、信号、信号量、消息队列和管道等。这些机制确保了管理进程可以有效地将任务分配给资源进程，并在任务完成后及时回收资源。

  4. 并发效果：由于进程池中的进程数量是固定的，因此同一时间最多只有固定数量的进程在运行。这种方式虽然限制了并发度，但也在一定程度上实现了并发效果，因为多个任务可以在不同的资源进程中并行处理。

二、使用匿名管道实现进程池的注意事项：

1、本文进程池的实现思路：

1.1、主函数逻辑
int main()
{
    // 创建任务
    CreateTask();

    std::vector<channel> channels;
    // 1、创建子进程池，子进程个数由用户进行输入
    if (CreatePipeAndProcess(channels, ExecuteTask))
    {
        std::cout << "进程池创建成功。" << std::endl;
    }
    else
    {
        std::cout << "进程池创建失败。" << std::endl;
    }
    // 发送执行任务,轮流向指定进程的管道中写入
    SendTask(channels, 30);
    sleep(5);
    // 关闭写端、回收子进程
    CloseWfdAndWaitChildProcess(channels);
    return 0;
}
1.2、父进程创建进程池并对子进程进行分流 

在父进程中使用fork()函数循环创建一定数量的子进程，当子进程创建完毕时，立即去等待处理父进程派发任务——即当管道写端未关闭且未读端未读取到数据时，子进程的运行会阻塞在read()处，直到读取到数据或写端关闭为止。因此，子进程不再参与后续子进程的创建（不再执行后续的循环代码，当子进程执行完自己的任务后直接使用exit函数退出进程），即进程池均由同一个父进程进行统一管理。

bool CreatePipeAndProcess(std::vector<channel> &channels, task_t handle_task)
{
    int pool_size = 0;
    std::cout << "请输入需要创建的进程池的大小：" << std::endl;
    std::cin >> pool_size;
    if (pool_size <= 0 || pool_size > POOL_SIZE)
    {
        std::cout << "进程池大小无效，创建失败！" << std::endl;
        return false;
    }
    for (int i = 0; i < pool_size; i++)
    {
        int pipefd[2] = {0};
        if (pipe(pipefd) < 0)
        {
            std::cerr << "管道创建失败！错误码：" << errno << std::endl;
            return false;
        }
        pid_t id = fork();
        if (id < 0)
        {
            std::cerr << "子进程创建失败！错误码：" << errno << std::endl;
            return false;
        }
        else if (id == 0)
        {
            // 1、关闭子进程的写端
            close(pipefd[1]);
            // 2、将子进程的读端重定向到子进程的标准输入流中
            dup2(pipefd[0], 0);
            // 由于子进程会继承父进程的文件描述符表，所以需要关闭所有其他管道的写端描述符
            if (!channels.empty())
                for (auto &ch : channels)
                {
                    ch.Close();
                }
            // 3、执行各自的任务
            handle_task();
            close(pipefd[0]); // 关闭原始读端描述符
            exit(0);          // 子进程正常退出
        }
        else
        {
            // 父进程负责建立进程池
            // 1、关闭读端
            close(pipefd[0]);
            // 2、存入管道的写端、进程标识符，构造channel
            char buffer[BUFFER_SIZE];
            memset(buffer, 0, sizeof(buffer));
            snprintf(buffer, sizeof(buffer), "Process - %d, id : %d", i, id);
            std::string description(buffer);
            channels.emplace_back(pipefd[1], description, id);
            // 父进程关闭管道写端后由子进程处理
        }
    }
    return true;
}

注意：子进程会继承父进程的文件描述符表。当创建第一个子进程时，正常关闭该进程的写端描述符即可。但从第二个子进程创建开始，每个进程都需要关闭从父进程继承而来的所有管道的写端文件描述符。

原因：1、关闭不需要使用的文件描述符可以减少资源浪费

2、主要原因：进程池中子进程的退出依赖于管道写端的关闭，只要管道中尚有写端存在，子进程就会一直阻塞在read()处，无法正常退出。因为每创建一个新的子进程，该子进程都会继承父进程的文件描述符表，这就导致了一个管道的写端被多个子进程指向。所以从第二个子进程创建开始，每个进程都需要关闭从父进程继承而来的所有管道的写端文件描述符！！！

else if (id == 0)
        {
            // 1、关闭子进程的写端
            close(pipefd[1]);
            // 2、将子进程的读端重定向到子进程的标准输入流中
            dup2(pipefd[0], 0);
            // 由于子进程会继承父进程的文件描述符表，所以需要关闭所有其他管道的写端描述符
            if (!channels.empty())
                for (auto &ch : channels)
                {
                    ch.Close();
                }
            // 3、执行各自的任务
            handle_task();
            close(pipefd[0]); // 关闭原始读端描述符
            exit(0);          // 子进程正常退出
        }
1.3、在每个子进程中将管道的读端重定向到标准输入流（0）的原因：
// 2、将子进程的读端重定向到子进程的标准输入流中
            dup2(pipefd[0], 0);
void ExecuteTask()
{
    int read_num = 0;
    int task_index = 0;
    while (true)
    {
        read_num = read(0, &task_index, sizeof(int));
        //..............
    }
}

 因为每个进程都是独立的，他们拥有各自的文件描述符表，在子进程内修改文件描述符表并不会影响到其他进程的文件描述符表的状态。使用dup2()函数将管道的读端重定向至标准输入流：是为了每个子进程都独立拥有一个管道，管道的读端文件描述符各不相同。重定向到标准输入流可以使每个子进程在读取数据时都可以从0号文件（即标准输入流）读取，因此可以减少传参操作，简化了数据的传输方式，同时使得读取操作在行为上也得到了统一。

2、子进程在何时退出？ 

 当需要让进程池停止运行时，主进程不再为进程池派发任务，即不再对管道进行写入操作。此时关闭所有管道的写端，则管道的读端使用read()函数的返回值为0，意味着写端已经关闭。此时我们对read()的返回值进行判断，返回值为0时终止子进程运行，等待父进程回收退出的子进程即可。当写端没有关闭但未写入数据时，读端会阻塞在read()函数处，所以不用担心管道中无数据时的返回值问题。

三、基于匿名管道通信实现的简易进程池完整代码

// 基于匿名管道的进程池实现，采用轮询方案使用进程池中的进程，模拟对多项任务的处理

#include <iostream>
#include <vector>
#include <functional>
#include <cstring>
#include <cerrno>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <ctime>
#include <string>

#define POOL_SIZE 10
#define TASK_SIZE 3
#define BUFFER_SIZE 512

using task_t = std::function<void()>;
// 创建任务栏
std::vector<task_t> tasks(TASK_SIZE);

void Print()
{
    std::cout << "I am print task" << std::endl;
}
void DownLoad()
{
    std::cout << "I am a download task" << std::endl;
}
void Flush()
{
    std::cout << "I am a flush task" << std::endl;
}

void CreateTask()
{
    srand(time(nullptr)); // 种下随机数种子
    tasks[0] = Print;
    tasks[1] = DownLoad;
    tasks[2] = Flush;
}
int GetNextChannelIndex(int channel_size)
{
    static int next = 0;
    int ret = (next++) % channel_size;
    return ret;
}
void ExecuteTask()
{
    int read_num = 0;
    int task_index = 0;
    while (true)
    {
        read_num = read(0, &task_index, sizeof(int));
        if (read_num == -1)
        {
            std::cerr << "管道读取失败！错误码：" << errno << std::endl;
            exit(-1);
        }
        else if (read_num == 0) // 读到0代表写端关闭，直接停止
        {
            std::cout << "子进程 " << getpid() << " 任务读取完成或管道关闭，退出。" << std::endl;
            break;
        }
        else
        {
            if (task_index >= 0 && task_index < TASK_SIZE)
            {
                std::cout << "子进程 " << getpid() << " 执行任务 " << task_index << std::endl;
                tasks[task_index]();
            }
            else
            {
                std::cerr << "无效的任务索引：" << task_index << std::endl;
            }
        }
    }
}

class channel
{
private:
    int _wfd;          // 管道的读端文件描述符
    std::string _name; // 管道的名称
    pid_t _pid;        // 子进程的标识符
public:
    channel(int wfd, const std::string &name, pid_t pid)
        : _wfd(wfd), _name(name), _pid(pid)
    {
    }
    int GetWfd()
    {
        return _wfd;
    }
    void Wait()
    {
        if (waitpid(_pid, nullptr, 0) > 0)
        {
            std::cout << "wait " << _pid << " success" << std::endl;
        }
        else
        {
            std::cout << "wait " << _pid << " false" << std::endl;
        }
    }
    void Close()
    {
        close(_wfd);
    }
    std::string& GetName(){
        return _name;
    }
};

bool CreatePipeAndProcess(std::vector<channel> &channels, task_t handle_task)
{
    int pool_size = 0;
    std::cout << "请输入需要创建的进程池的大小：" << std::endl;
    std::cin >> pool_size;
    if (pool_size <= 0 || pool_size > POOL_SIZE)
    {
        std::cout << "进程池大小无效，创建失败！" << std::endl;
        return false;
    }
    for (int i = 0; i < pool_size; i++)
    {
        int pipefd[2] = {0};
        if (pipe(pipefd) < 0)
        {
            std::cerr << "管道创建失败！错误码：" << errno << std::endl;
            return false;
        }
        pid_t id = fork();
        if (id < 0)
        {
            std::cerr << "子进程创建失败！错误码：" << errno << std::endl;
            return false;
        }
        else if (id == 0)
        {
            // 1、关闭子进程的写端
            close(pipefd[1]);
            // 2、将子进程的读端重定向到子进程的标准输入流中
            dup2(pipefd[0], 0);
            // 由于子进程会继承父进程的文件描述符表，所以需要关闭所有其他管道的写端描述符
            if (!channels.empty())
                for (auto &ch : channels)
                {
                    ch.Close();
                }
            // 3、执行各自的任务
            handle_task();
            close(pipefd[0]); // 关闭原始读端描述符
            exit(0);          // 子进程正常退出
        }
        else
        {
            // 父进程负责建立进程池
            // 1、关闭读端
            close(pipefd[0]);
            // 2、存入管道的写端、进程标识符，构造channel
            char buffer[BUFFER_SIZE];
            memset(buffer, 0, sizeof(buffer));
            snprintf(buffer, sizeof(buffer), "Process - %d, id : %d", i, id);
            std::string description(buffer);
            channels.emplace_back(pipefd[1], description, id);
            // 父进程关闭管道写端后由子进程处理
        }
    }
    return true;
}
void SendTaskOnce(std::vector<channel> &channels)
{
    // 1、选择一个进程
    int channel_index = GetNextChannelIndex(channels.size());
    // 2、选择一个任务
    int task_index = rand() % TASK_SIZE;
    std::cout << "发送任务 " << task_index << " 到进程 " << channels[channel_index].GetName() << std::endl;
    // 3、向指定子进程管道中写入任务码
    if (write(channels[channel_index].GetWfd(), &task_index, sizeof(int)) == -1)
    {
        std::cout << "管道写入失败！" << std::endl;
        exit(-1);
    }
}
void SendTask(std::vector<channel> &channels, int counts)
{
    while (counts--)
    {
        SendTaskOnce(channels);
    }
}
void CloseWfdAndWaitChildProcess(std::vector<channel> &channels)
{
    for (auto &ch : channels)
    {
        ch.Close();
        ch.Wait();
    }
}
int main()
{
    // 创建任务
    CreateTask();

    std::vector<channel> channels;
    // 1、创建子进程池，子进程个数由用户进行输入
    if (CreatePipeAndProcess(channels, ExecuteTask))
    {
        std::cout << "进程池创建成功。" << std::endl;
    }
    else
    {
        std::cout << "进程池创建失败。" << std::endl;
    }
    // 发送执行任务,轮流向指定进程的管道中写入
    SendTask(channels, 30);
    sleep(5);
    // 关闭写端、回收子进程
    CloseWfdAndWaitChildProcess(channels);
    return 0;
}

这题怎么做？！？
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
『 Linux 』匿名管道应用 - 简易进程池
小侯宝的博客
07-13 970
当一种资源需要被使用时这意味着这个资源可能会被进行多次使用或者需要同时使用多个该资源,当出现这种情况时内核将会频繁的对该资源进行申请并释放,大大降低整体的效率;整体构造采用先描述后组织的方式对进程池进行设置,并以自顶向下的方式进行设计,即先将所需接口以声明的形式标出而后再对接口进行具体实现;本文模拟实现的进程池通过多个匿名管道实现进程间通信使得一个进程与多个其对应的血缘关系进程进行协同从而形成一个进程池[父写子读];子进程为父进程的一份拷贝,当父子进程中其中一个进程被修改时(即对物理内存进行修改);
Linux——匿名管道、命名管道及进程池概念和实现原理
weixin_61857742的博客
12-04 2268
管道是linux中一种非常古老的进程间通信方式，本质上就是一个内存级的文件。一般用于父子进程间通信。概念上就是父进程与子进程共同使用一个管道文件来传输数据。虽然父子进程都有对管道的读和写功能，但在使用时只能读或者写，因此管道是单向通信，半双工模式。
【Linux】进程间通信——匿名管道|命名管道
qq_64076540的博客
04-07 668
进程间通信，顾名思义就是两个进程互相通信。可是进程是独立的，该如何通信呢？类比你和你的朋友在网上聊天，你们两个人也是独立的，是如何通信的呢？因为你能看到你朋友给你发的消息，你朋友也能看到这份消息。这个消息就是一个公共的资源。所以进程间如果要进行通信，就需要两个进程看到同一份资源。那么，通信的地点在哪里呢？很明显，因为进程之间是独立的，所以通信的地点肯定不能在进程中，只能在操作系统中。结论：进程间通信的地点是操作系统。进程间通信的方式有很多，一般有三种：1.管道：通过文件系统通信。匿名管道。
Linux进程间通信【命名管道】
热门推荐
北 海的博客
06-07 1万+
命名管道通信属于IPC的其中一种方式，作为管道家族，命名管道的特点就是自带同步与互斥机制、数据单向流通，与匿名管道不同的是：命名管道有自己的名字，因此可以被没有血缘关系的进程看到，意味着命名管道可以实现毫不相干的两个独立进程间通信
Linux进程间通信【匿名管道】
北 海的博客
06-05 9608
进程间通信简称为IPC（Interprocess communication），是两个不同进程间进行任务协同的必要基础。进行通信时，首先需要确保不同进程之间构建联系，其次再根据不同的使用场景选择不同的通信解决方案，本文主要介绍的通信解决方案为匿名管道
Linux使用匿名管道实现进程池得以高效通信
B1ue还在专注
01-29 2171
本文是对于匿名管道知识点综合的应用，实现了一个简易的进程池[○･`Д´･○]
Linux进程间通信—管道
m0_61986874的博客
05-24 249
Linux进程通信——管道（匿名管道和命名管道）
【Linux笔记】进程间通信之管道
kk702392702的博客
02-14 1124
大家在学习C++的时候可能听说过空间配置器，也可能听说过进程池，但可能并不真正理解这些到底是个什么东西。通俗的理解，我们可以将进程池理解成一个内存储备库。我们在学习C语言的时候用过malloc，学习C++的时候用过new，它们两个的作用都是申请一块内存空间供用户使用。而且我们也知道操作系统是内存的管理者，所以分配内存资源的工作只能有操作系统来做，而我们要访问操作系统只能通过系统调用。那么如果我们要频繁使用malloc或new来申请空间，难道是每次都要调用系统调用吗？
简易进程池的实现
weixin_60358305的博客
05-25 535
进程池（Process Pool）是一种用于管理和复用多个进程的技术或设计模式。在进程池中，一定数量的进程会被预先创建并保持在内存中，以便在需要时立即使用，而不是每次需要进程时都重新创建新的进程，这样可以提高系统的性能和效率。进程池通常用于需要频繁创建和销毁进程的场景，例如网络服务器等。通过预先创建一些进程并保持它们处于空闲状态，可以避免频繁创建和销毁进程所带来的开销，并且可以更好地控制同时进行的进程数量，以避免系统资源被耗尽。
Linux通过匿名管道进行进程间通信
09-15
【Linux匿名管道进程间通信详解】 在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现不同进程间数据共享和协调工作的重要手段。本文将深入探讨一种常见的IPC方式——匿名管道，以及如何...
实验四：Linux下进程管道通信.docx
04-13
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
电子科大操作系统实验课Linux通过管道实现进程间通信
01-05
- 实验强调了管道通信的实现方式以及进程间的同步控制，通过`wait()`和`exit()`确保数据正确传输。 - 管道通信的效率相对较低，适合数据量小、实时性要求不高的场景。 - 父进程需谨慎处理管道读写，以防止数据...
Python进程通信之匿名管道实例讲解
09-22
本文将详细讲解Python中如何使用匿名管道实现进程间的通信。 匿名管道是一种简单但基础的进程间通信（IPC）方式，它提供了一个单向的数据通道。在Python中，我们可以使用`os`模块提供的`pipe()`函数创建匿名管道。`...
Linux：基础命令学习
qq_55038440的博客
07-20 1490
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
LINUX之MMC子系统分析
gy794627991的博客
07-23 1089
MMC子系统从协议到源码分析
RockyLinux 9 PXE Server bios+uefi 自动化部署 RockLinux 8 9
极致，细节
07-24 93
PXE（Preboot eXecution Environment，预启动执行环境）是一种网络启动协议，允许计算机通过网络启动而不是使用本地硬盘。PXE服务器是实现这一功能的服务器，它提供了启动镜像和引导加载程序，使得客户端计算机可以通过网络启动并安装操作系统或运行其他软件。
(leetcode学习)110. 平衡二叉树
最新发布
m0_54888411的博客
07-24 372
很久没写结构体了，复习一下。学习二叉树的通用解题方法。给定一个二叉树，判断它是否是。
Linux：进程信号（一.认识信号、信号的产生及深层理解、Term与Core）
qq_74415153的博客
07-23 1555
1.认识信号 进程看待信号方式 2.信号的产生 2.1信号的处理的方式 --- signal()函数 2.2kil指令产生信号 2.3键盘产生信号 2.4系统调用发送信号 -kil系统调 用、raise()和abort()库函数 2.5软件条件产生信号 2.6异常产生信号 3.信号产生的深层理解 键盘产生信号 异常产生信号 4.Term与Core core文件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

这题怎么做？！？

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

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

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

打赏作者

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

抵扣说明：

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

余额充值