Linux--构建进程池

于 2024-05-28 13:43:13 发布
阅读量1k 收藏 9
点赞数 33
分类专栏： Linux学习 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76618602/article/details/139215367
版权

目录

 1.进程池

1.1.我们先完成第一步，创建子进程和信道

1.2. 通过channel控制，发送任务

1.3回收管道和子进程

1.4进行测试

1.5完整代码

 1.进程池

进程池其产生原因主要是为了优化大量任务需要多进程完成时频繁创建和删除进程所带来的资源消耗，以及更好的实现多个进程间的协同。以下是关于进程池的一些关键点：

  1. 组成：进程池技术主要由两部分组成：资源进程和管理进程。资源进程是预先创建好的空闲进程，等待管理进程分发任务（maste向哪个管道写入，就是唤醒哪一个子进程处理任务）。管理进程则负责创建这些资源进程，将工作分配给空闲的资源进程处理，并在工作完成后回收这些资源进程。（父进程要进行后端任务的负载均衡）
  2. 管理：管理进程如何有效地管理资源进程是关键。这涉及到分配任务给资源进程、回收空闲资源进程等操作。管理进程和资源进程之间需要进行交互，这种交互可以通过管道（需要子进程执行一个任务我们就可以派发一个管道，连接一个子进程，执行任务）
  3. 使用场景：当我们需要并行的处理大规模任务时，比如服务器处理大量客户端的任务，进程池是一个很好的选择。它可以避免频繁创建和销毁进程的开销，提高应用的响应速度。
  4. 优化：使用进程池可以避免动态创建和销毁进程的开销，提高应用的性能和稳定性。此外，进程池还可以根据任务的执行情况尽量减少创建的进程数量，最多创建指定个数的进程。

代码实现：

        实现进程池首先我们需要提前准备好一批数量的进程，当一个任务队列被提交到线程池，每个工作进程都会不断从任务队列中取出任务并执行。

1.1.我们先完成第一步，创建子进程和信道

        

        Channel类是来管理一个子进程和与之相关联的管道写端，这个Channel类就是信道。用于一个需要管理多个子进程和它们各自管道写端的程序中。例如，你可能有一个父进程，它创建多个子进程，每个子进程都通过管道与父进程通信。在这种情况下，你可以为每个子进程和它的管道写端创建一个Channel对象，并使用这些对象来管理它们。

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;//写端fd
    pid_t _subprocessid;//子进程id'
    std::string _name;//一个信道的名称
};

        下面函数的主要逻辑是创建多个管道和相应的子进程，每个子进程都将从它自己的管道中读取数据，而父进程则保留管道的写端以便后续向子进程发送数据。同时，这个函数也维护了一个 Channel 对象的向量（std::vector<Channel>），其中每个 Channel 对象代表一个与特定子进程和管道写端相关联的通道。

        task_t是一个函数指针类型，是为了泛型，将来可以传任意不同的任务交给子进程做。

可以理解为回调函数 task 的使用降低了任务与子进程之间的耦合度。在传统的编程模型中，你可能会为每个子进程编写特定的代码块，这些代码块直接嵌入在创建子进程的函数中。这样做会导致代码的高耦合性，因为每个子进程的行为都紧密地绑定在创建它们的函数中。（关于task的应用见下文）

        dup2(pipefd[0], 0)将管道的读端，重定向到标准输入。意思就是管道的读端变成了标准输入，无需修改代码以处理文件描述符，因为以后任意的子进程去读取任务，都是从标准输入去读取的。

        在子进程中，它关闭了管道的写端，将读端重定向到标准输入，执行给定的回调函数 task，然后关闭读端并退出。

void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

提供一个任务文件，接下来让子进程执行任务：

#pragma once

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

#define TaskNum 3

typedef void (*task_t)(); // task_t 函数指针类型

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;
}

task_t tasks[TaskNum];

void LoadTask()
{
    srand(time(nullptr) ^ getpid() ^ 17777);
    tasks[0] = Print;
    tasks[1] = DownLoad;
    tasks[2] = Flush;
}

void ExcuteTask(int number)
{
    if (number < 0 || number > 2)
        return;
    tasks[number]();
}

int SelectTask()
{
    return rand() % TaskNum;
}

void work()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(command));
        if (n == sizeof(int))
        {
            std::cout << "pid is : " << getpid() << " handler task" << std::endl;
            ExcuteTask(command);
        }
        else if (n == 0)
        {
            std::cout << "sub process : " << getpid() << " quit" << std::endl;
            break;
        }
    }
}
  • 初始化阶段：LoadTask()函数被调用，设置tasks函数指针数组以包含所有可用的任务函数，通过索引调用三个具体的任务函数：Print(), DownLoad(), 和 Flush()。
  • 任务选择阶段：SelectTask()函数在需要时用于生成一个随机任务索引。
  • 任务执行阶段：在子进程中，work()函数不断监听标准输入，等待一个任务索引。一旦接收到索引，就调用ExcuteTask()来执行相应的任务。

子进程退出：当子进程从标准输入读取到0时，它知道应该退出循环并结束。

1.2. 通过channel控制，发送任务

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}
void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}
  1.   NextChannel 函数是一个轮询选择器，用于在给定的通道数量（channelnum）中循环选择一个通道索引。它使用了一个静态变量 next 来跟踪上一次选择的索引，并在每次调用时递增这个索引。
  2.  SendTaskCommand 函数用于向指定的 Channel 对象（代表一个与子进程的通信通道）发送一个任务命令（taskcommand）。它通过调用 Channel 对象的 GetWfd 方法获取管道的写端文件描述符，然后使用 write 系统调用来将任务命令写入管道。这样，子进程就可以从管道中读取这个命令并执行相应的任务。
  3.  ctrlProcessOnce 函数模拟了控制进程的一次操作。调用 NextChannel 函数来选择一个通道索引，并通过该索引从 channels 向量中获取一个 Channel 对象。然后，它调用 SendTaskCommand 函数向选定的通道发送任务命令。最后，它打印出相关的信息，包括任务命令、通道名称和子进程的进程ID，以便进行调试和监控。               
  4. ctrlProcess 函数是控制进程的主循环。它接受一个 channels 向量和一个可选的 times 参数。如果 times 大于0，则控制进程会循环执行 ctrlProcessOnce 函数 times 次；如果 times 小于或等于0（默认为-1），则控制进程会无限循环地执行 ctrlProcessOnce 函数

1.3回收管道和子进程

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;//写端fd
    pid_t _subprocessid;//子进程id'
    std::string _name;//一个信道的名称
};

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
    }
    for (auto &channel : channels)
    {
        channel.Wait();
    }
}

a. 关闭所有的写端 b. 回收子进程

注意：一定是先关闭全部读端，然后统一读端，而不能关一个，等待一个。

在执行子进程创建逻辑的时候，是存在bug的。

我们在创建第一个信道的时候是没有什么问题的：

接着来看，我们创建第二个信道会发生什么：fd[4]的指向被第二个信道的子进程继承了，那么第一个管道的写端就个fd指向了，这就是坑

如果继续创建更多的信道，那么这种情况会一直累积，只有最后一个文件只有一个写端。如果我们是关一个等待一个，那么第一个信道，只会关闭一个读端，但还有其它的读端，这就会发生进程阻塞，导致管道文件一直在等待读取，无法被释放；如果统一的关闭读端，那么当关闭到最后一个信道的时候，最后一个信道读端只有一个，管道文件会被释放，然后就会递归式的逆向关闭其它信道的所有读端，最后将所有的管道文件释放，父进程只需要一 一等待，就能回收所有子进程了。

1.4进行测试

子进程执行任务成功，父进程回收子进程成功。

1.5完整代码

Task.hpp

#pragma once

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

#define TaskNum 3

typedef void (*task_t)(); // task_t 函数指针类型

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;
}

task_t tasks[TaskNum];

void LoadTask()
{
    srand(time(nullptr) ^ getpid() ^ 17777);
    tasks[0] = Print;
    tasks[1] = DownLoad;
    tasks[2] = Flush;
}

void ExcuteTask(int number)
{
    if (number < 0 || number > 2)
        return;
    tasks[number]();
}

int SelectTask()
{
    return rand() % TaskNum;
}

void work()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(command));
        if (n == sizeof(int))
        {
            std::cout << "pid is : " << getpid() << " handler task" << std::endl;
            ExcuteTask(command);
        }
        else if (n == 0)
        {
            std::cout << "sub process : " << getpid() << " quit" << std::endl;
            break;
        }
    }
}

test.cc

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp"

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;
    pid_t _subprocessid;
    std::string _name;
};

//  task_t task: 回调函数
void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}

void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
        
    }
    for (auto &channel : channels)
    {
        
        channel.Wait();
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " processnum" << std::endl;
        return 1;
    }
    int num = std::stoi(argv[1]);
    LoadTask();

    std::vector<Channel> channels;
    // 1. 创建信道和子进程
    CreateChannelAndSub(num, &channels, work);

    // 2. 通过channel控制子进程
    ctrlProcess(channels, 10);

    // 3. 回收管道和子进程. a. 关闭所有的写端 b. 回收子进程
    CleanUpChannel(channels);

    // sleep(100);
    return 0;
}#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp"

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;
    pid_t _subprocessid;
    std::string _name;
};

//  task_t task: 回调函数
void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}

void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
        
    }
    for (auto &channel : channels)
    {
        
        channel.Wait();
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " processnum" << std::endl;
        return 1;
    }
    int num = std::stoi(argv[1]);
    LoadTask();

    std::vector<Channel> channels;
    // 1. 创建信道和子进程
    CreateChannelAndSub(num, &channels, work);

    // 2. 通过channel控制子进程
    ctrlProcess(channels, 10);

    // 3. 回收管道和子进程. a. 关闭所有的写端 b. 回收子进程
    CleanUpChannel(channels);

    // sleep(100);
    return 0;
}

momo小菜pa
关注
  • 33
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Linux进程池.zip
08-12
Linux进程池是一种高级的系统...通过理解和掌握以上知识点，开发者可以构建一个高效的Linux进程池，实现对并发任务的有效管理和调度。同时，需要注意的是，进程池的设计应当灵活可扩展，以适应不同应用场景的需求变化。
【Linux】高性能服务器编程（一）——多进程/多线程和进程池/线程池
IT_Mitchell的博客
07-29 615
如何实现同一时刻能与多个客户端同时交互？我们希望是服务器与多个客户端交互以并发进行处理。在我们高性能服务器编程下有这样几种方法，一是多进程/多线程，二是进程池/线程池，三是I/O复用。 目录 一、多进程/多线程 （一）多进程 （二）多线程：启动多个线程，每个线程执行和一个客户端交互的程序； （三）两者的选择和比较 1、多进程和多线程的选择 2、多进程/多线程实现并发的缺陷： 二、进...
进程池(multiprocess.Pool)
淘小欣的博客
02-19 6621
进程池(multiprocess.Pool) 一、进程池概念 1.什么是进程池? ????进程池是资源进程, 管理进程组成的技术的应用. 2.为什么要有进程池? ????忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。 ????那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？ ????首先，创建进程需要消耗时间，销毁进程也需要消耗时间。 ????第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。 ????因此我们不能无限制的根据任务去开
Python高阶语法--进程池
lee_881的博客
01-13 2786
Python高阶语法--进程池
python—多进程之进程池
python全栈
10-12 5639
一、进程池 1、进程池定义： 进程池：可以提供指定数量的进程给用户使用,即当有新的请求提交到进程池中时，如果池未满，则会创建一个新的进程用来执行该请求;反之，如果池中的进程数已经达到规定最大值，那么该请求就会等待，只要池中有进程空闲下来，该请求就能得到执行。 2、原理图 绿色：子进程没有工作，处于空闲状态（子进程没有调用任务函数） 粉色：子进程处于工作状态（子进程调用了任务函数） 3、使用进程池的优点 1.提高效率，节省开辟进程和开辟内存空间的时间及销毁进程的时间 2.节省内存空间 4、Pool中的函数
进程池是干什么的？底层原理是什么？
长风破浪会有时的博客
05-10 244
程序在启动时会创建一定数量的进程，并将它们保存在池中。当有任务到来时，程序会从池中选择一个空闲的进程，并将任务参数传递给该进程。进程池是一种常见的多进程编程技术，它可以在程序启动时预先创建一定数量的进程，并将这些进程保存在池中以备后续使用。当有任务需要处理时，程序会从进程池中取出一个空闲的进程来处理任务，任务处理完毕后，该进程会被放回进程池中，等待下一个任务的到来。进程池技术可以显著提高程序的性能和并发处理能力，因为它避免了频繁地启动和关闭进程的开销，而是预先创建了一定数量的进程，并且这些进程可以被复用。
进程池原理
极客神殿
06-06 267
进程池（Process Pool）是一种常见的多进程编程技术，用于提高并发处理能力和资源利用率。它的基本原理是创建一组可重用的进程，这些进程可以接收任务，执行任务，然后返回执行结果。进程池通常会限制进程的数量，以避免资源过度消耗和系统负载过重。上面的代码中，首先定义了一个worker函数，它表示需要执行的任务，并返回任务的执行结果。然后，创建了一个包含 4 个进程的进程池，通过map方法将任务分发给进程池中的进程执行，并收集执行结果。因此，在使用进程池时需要根据具体的应用场景进行权衡和选择。
linux-jdk,tomcat,zookeeper，dubbo
08-02
Linux的命令行界面提供了丰富的工具进行系统管理，如文件操作、网络配置、进程管理等。理解Linux基础是成为一名合格的IT专业人员的必备技能。 2. **JDK（Java Development Kit）**：JDK是Java编程语言的开发和运行...
Embedded-Linux-Kernel-Programming
04-10
在嵌入式Linux中，内存管理包括物理内存分配、虚拟内存映射、内存池管理等。理解如何有效地分配和回收内存，避免内存泄漏，是保证系统稳定运行的基础。C语言的指针操作在此过程中扮演了重要角色。 六、线程与进程...
swoole_process实现进程池的方法示例
10-17
【swoole_process实现进程池方法详解】 `swoole_process`是Swoole扩展提供的一种在PHP中创建和管理进程的工具，它使得在PHP中实现进程池变得相对简单。进程池是一种有效的资源管理策略，它能根据系统负载动态调整...
基于进程池的Linux并发服务器的研究.pdf
09-06
本文主要探讨了在Linux操作系统环境下，如何利用进程间通信（IPC）、套接字通信、共享内存以及进程池技术来构建高性能并发服务器。 1. **进程间通信（IPC）**： 在Linux系统中，进程间通信是实现多个进程协同工作...
【Linux】进程间管道通信、线程池
Brant_zero的博客
01-14 597
Linux中进程间通信，讲解进程间通信实现的原理、进程间通信的方式，匿名管道、使用匿名管道模拟实现进程池；命名管道的创建与使用，使用命名创建子进程，让子进程处于读取状态争抢任务。
Linux——进程池
最新发布
qq_67693066的博客
03-05 1098
Linux——进程池
进程池详解（linux）
weixin_42250655的博客
10-14 953
进程池 进程池是我们创建一组进程，进程数目可以自己的规定，目的是为了让我们可以并发的去处理任务，此文处理的是网络请求的进程池。 采用的是半同步/半反应堆模式的进程池。 主进程epoll监听listenfd,如有客户连接根据特定算法将客户连接套接字利用管道发送给进程池中的某个进程，让其进行监听。该算法主要是为了平衡进程池中每个进程epoll监听的套接字数量。防止某个进程监听过多性能降低。 然后每个进...
进程（六）：进程池（Pool）
。
11-13 8470
目录 进程池 multiprocess.Pool模块 概念介绍 参数介绍 主要方法 其他方法(了解） 代码实例 回调函数 进程池 为什么要有进程池?进程池的概念。 在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便...
进程池简述
python -学习笔记
10-17 719
进程池技术     产生原因:如果有大量任务需要多进程完成,则可能需要频繁的创建删除进程,给计算机带来较多的资源消耗     原理:创建适当的进程放入进程池,用来处理待处理事件,处理完毕之后进程不销毁,              仍然在进程池中等待处理其他事件.进程的复用降低了资源的消耗     使用方法:         1.创建进程池,在池内放入适当的进程(4-8个)         2....
进程间通信基础知识【Linux】——上篇【进程通信，管道，进程池实现】
菜菜成长为后端开发大佬
11-29 1556
目录一，理解进程之间的通信1. 进程间通信目的2. 进程间通信的技术背景3，常见的进程间通信二，管道1. 尝试建立一个管道管道的特点：管道提供的访问控制：2. 扩展：进程池阶段一： 创建多个子进程阶段二：构建命令方法ProcessPool.cpptask.hpp下一期：进程通信基础知识结语首先，系统在设计时，秉持这相互独立的原则，因此要想实现进程之间的通信是比较困难的。而进程之间的通信本质上是：不同的进程能访问同一份数据。1）进程是具有独立性的，虚拟地址 + 页表 保证进程之间的独立性 （内核中数据结构 ，
Python中多进程和进程池的使用方法
程序员小麦的博客
12-01 1188
本篇博客介绍了Python中多进程和进程池的使用方法，并提供了一些实用的案例供读者参考。多进程和进程池是Python中强大的功能之一，可以帮助我们更加高效地利用CPU资源，提高程序的运行速度。在实际应用中，需要根据具体情况选择合适的方案来实现多进程和进程池。
《Linux系统编程》中文版-运维技术书籍
这本书涵盖了Linux系统编程的核心概念，包括进程管理、文件I/O、信号处理、网络编程、内存管理、多线程编程、系统调用接口等多个关键领域。 在进程管理方面，书籍会讲解如何创建、控制和通信进程，以及进程间同步和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值