Linux多进程(五) 进程池 C++实现

一、进程池的概念

1.1、什么是进程池

进程池是一种并发编程模式,用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况,以避免因此产生的开销。

进程池的优点包括:

  1. 减少进程创建销毁的开销:避免频繁创建和销毁进程所带来的系统资源开销。
  2. 提高系统响应速度:由于进程已经初始化并且一直保持在内存中,可以立即分配执行任务,减少了任务等待时间。
  3. 控制资源使用:通过限制进程池中的进程数量,可以控制系统资源的使用情况,避免资源过度消耗。

1.2、管理进程

预先创建一些空闲进程,管理进程会把工作分发到空闲进程来处理,空闲进程处理结束后,通知管理进程。

管理进程需要将任务发给空闲的工作进程,这里就涉及到进程之间的通信,进程间的通信有以下三种方式,我们之前都做了详细的解释

管道:https://blog.csdn.net/weixin_43903639/article/details/138155634?spm=1001.2014.3001.5501

消息队列:https://blog.csdn.net/weixin_43903639/article/details/138155723?spm=1001.2014.3001.5501

共享内存:https://blog.csdn.net/weixin_43903639/article/details/138189200?spm=1001.2014.3001.5501

二、进程池模型

对于一个进程池,我们需要维护一个进程队列,如果进程在忙就等待,如果进程空闲,那么就给空闲进程发任务让进程去处理。

三、进程通信

我们这里采用了有名管道的方式。实际上使用匿名管道是一样的。为了方便管理,我们这里创建了一个Fifo的类,通过类将管道视为一个个的对象。

cpp 复制代码
// 权限
#define Mode 0666
// 文件地址
#define Path "./default"

class Fifo
{
public:
    Fifo(string path = Path, int mode = Mode) : _path(path), _mode(mode)
    {
        int return_mkfifo_val = mkfifo(_path.c_str(), _mode);
        if (return_mkfifo_val < 0)
        {
            cout << "mkfifo error:" << errno << " reason :" << strerror(errno) << endl;
            exit(1);
        }
        cout << "mkfifo success" << endl;
    }

    ~Fifo()
    {
        int return_unlink_val = unlink(_path.c_str());
        if (return_unlink_val < 0)
        {
            cout << "unlink error:" << errno << " reason :" << strerror(errno) << endl;
        }
        cout << "unlink namepipe success" << endl;
    }

private:
    string _path;
    int _mode;
};

管道的默认权限是 0666,管道的默认文件地址是 ./default,这样管理的优势是便于管道的创建与销毁。

三、进程对象

我们将一个进程也视为一个对象,那么一个进程就需要以下的元素

  • fd0 : 管道,通过这个管道接收主进程的数据
  • fd1:管道,通过这个管道给主进程发数据
  • pid:子进程的pid
  • isbusy:此子进程是否在忙
cpp 复制代码
class Process
{
public:
    Process(int fd0, int fd1, pid_t process_pid) : _fd0(fd0), _fd1(fd1), _process_pid(process_pid), _isbusy(false) {}

    ~Process() {}

    // 获取父进程要写入的管道
    int get_fd0() { return _fd0; }

    // 获取子进程要写入的管道
    int get_fd1() { return _fd1; }

    // 获取子进程pid
    pid_t get_process_pid() { return _process_pid; }

    // 获取是否忙碌标志位
    bool get_isbusy() { return _isbusy; }

    // 修改标志为
    void set_isbusy(bool flag) { _isbusy = flag; }

private:
    int _fd0;           // 父进程要写入的管道
    int _fd1;           // 父进程要读入的管道
    pid_t _process_pid; // 子进程pid
    bool _isbusy;       // 是否忙碌标志位
};

四、进程池

进程池就是同时管理管道和进程的。其中包含多个进程对象,每个进程对象又要包含两个管道。

  • vector<string> pipe0 主进程写入,子进程读的管道名
  • vector<string> pipe1 子进程写入,主进程读的管道名
  • vector<Fifo *> fifo0 主进程写入,子进程读的管道
  • vector<Fifo *> fifo1 子进程写入,主进程读的管道
  • vector<Process> _processpool 进程池管理的进程
  • int _processnum 进程池管理的进程数量
cpp 复制代码
// 进程池
class ProcessPool
{
public:
    ProcessPool(int processnum) : _processnum(processnum) {}

    ~ProcessPool()
    {
        for (int i = 0; i < _processnum; i++) {
            delete fifo0[i];
            delete fifo1[i];
        }
        // 要释放所有的子进程
        for (int i = 0; i<_processnum; i++) {
            // 通知子进程结束,通知失败的话直接杀死子进程
            if (kill(_processpool[i].get_process_pid(), SIGTERM) != 0) {
                // 杀死子进程
                kill(_processpool[i].get_process_pid(), SIGUSR1);
            }
        }
    }

    // 生成管道的名字
    void makePipeName()
    {
        pipe0.clear();
        pipe1.clear();
        for (int i = 0; i < _processnum; i++)
        {
            string s0;
            s0 += "pipe0_" + to_string(i + 1);
            pipe0.push_back(s0);
            string s1;
            s1 += "pipe1_" + to_string(i + 1);
            pipe1.push_back(s1);
        }
    }

    // 创建进程池,接收一个参数的函数指针
    void CreateProcessPool(work_t work = worker)
    {
        for (int i = 0; i < _processnum; i++)
        {
            // 创建命名管道
            fifo0.push_back(new Fifo(pipe0[i]));
            fifo1.push_back(new Fifo(pipe1[i]));

            int id = fork();
            if (id == 0)
            {
                // 子进程
                int fd0 = open(pipe0[i].c_str(), O_RDONLY);
                int fd1 = open(pipe1[i].c_str(), O_WRONLY);
                work(fd0, fd1);
                exit(0);
            }

            // 父进程打开管道,未发送任务
            int fd0 = open(pipe0[i].c_str(), O_WRONLY);
            int fd1 = open(pipe1[i].c_str(), O_RDONLY | O_NONBLOCK);
            // 设置为非阻塞模式
            fcntl(fd1, F_SETFL, O_NONBLOCK);
            _processpool.push_back({fd0, fd1, id});
        }
    }

    // 找到空闲进程返回进程在_processpool中的序号,没找到返回-1
    int getAChannal()
    {
        for (int i = 0; i < _processnum; i++)
        {
            if (_processpool[i].get_isbusy() == false) {
                _processpool[i].set_isbusy(true);
                return i;
            }
        }
        return -1;
    }

    // 发送任务,任务就是数据
    void SendTask(char *data, int datasize)
    {
        // 随机选中管道
        int luck_process = getAChannal();
        while (luck_process == -1) {
            // 看一下哪些进程是空闲的。每个进程结束后都会发送自己的pid。
            for (int i=0; i<_processnum; i++) {
                pid_t pid = 0;
                ssize_t bytes_read = read(_processpool[i].get_fd1(), &pid, sizeof(pid_t));
                if (bytes_read == -1) continue;
                // 哪个进程返回了数据,就认为Ta结束了。
                else {
                    _processpool[i].set_isbusy(false);
                }
            }
            luck_process = getAChannal();
        }

        // 父进程向管道发送任务,发送任务就是向相应的管道写入数据
        write(_processpool[luck_process].get_fd0(), data, datasize);
    }

    static void worker(int fd0, int fd1)
    {
        char buf[BUFSIZ];
        while (1)
        {
            int read_return_value = read(fd0, buf, BUFSIZ);
            // 处理读取到的数据
            if (read_return_value > 0)
            {
                cout << "my data is : " << buf << " my pid is : " << getpid() << endl;
                // 模拟处理读取到的数据
                sleep(1);
            }
            // 向消息队列传递自己的pid,表示已经完成任务
            pid_t pid = getpid();
            write(fd1, &pid, sizeof(pid_t));
        }
    }

private:
    int _processnum;
    vector<string> pipe0; // 父进程写入,子进程读
    vector<string> pipe1; // 子进程写入,父进程读
    vector<Fifo *> fifo0;
    vector<Fifo *> fifo1;
    vector<Process> _processpool;
};

五、仿真

这里我们的工作函数是默认的工作函数,也就是打印传入的数据。

c 复制代码
#include "ProcessPool.h"
#include <iostream>

int main(int argc, char* argv[])
{
    ProcessPool* processpool = new ProcessPool(5);
    processpool->makePipeName();
    processpool->CreateProcessPool();

    char buf[3];

    for (int i=0;i<20;i++) {
        sprintf(buf,"%d",i+100);
        processpool->SendTask(buf,3);
    }

    delete processpool;
    
    return 0;
}

看一下仿真结果

相关推荐
C++忠实粉丝7 分钟前
计算机网络socket编程(3)_UDP网络编程实现简单聊天室
linux·网络·c++·网络协议·计算机网络·udp
计算机毕设指导612 分钟前
基于 SpringBoot 的作业管理系统【附源码】
java·vue.js·spring boot·后端·mysql·spring·intellij-idea
Gu Gu Study14 分钟前
枚举与lambda表达式,枚举实现单例模式为什么是安全的,lambda表达式与函数式接口的小九九~
java·开发语言
Chris _data16 分钟前
二叉树oj题解析
java·数据结构
牙牙70522 分钟前
Centos7安装Jenkins脚本一键部署
java·servlet·jenkins
量子网络25 分钟前
debian 如何进入root
linux·服务器·debian
paopaokaka_luck30 分钟前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
我们的五年33 分钟前
【Linux课程学习】:进程描述---PCB(Process Control Block)
linux·运维·c++
以后不吃煲仔饭42 分钟前
Java基础夯实——2.7 线程上下文切换
java·开发语言
进阶的架构师43 分钟前
2024年Java面试题及答案整理(1000+面试题附答案解析)
java·开发语言