c语言进程池原理及实现

最新推荐文章于 2024-05-28 13:43:13 发布
最新推荐文章于 2024-05-28 13:43:13 发布
阅读量1.6k 收藏 9
点赞数 1
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jenie/article/details/106453811
版权

进程池与线程池出发点一样，都是考虑多核情况下任务的并行处理；
从多进程和多线程编程的区别上看，多线程有许多的同步、互斥的方法，较擅长于异步协作；而多进程同步、互斥的方法相对比较麻烦，则更多地考虑上下文独立执行；
从Nginx使用线程池/进程池处理大并发的思路去分析，其实就是多客户端大量连接的场景；主进程监听是否有新客户端tcp连接，然后分发给工作进程去响应http请求，在这种场景下每个连接都是一个独立的上下文逻辑，每个工作进程的内容都是对等地处理http请求，这种情况就非常适合进程池的方式；
 

把上述的场景给抽象出来，关注于父子进程的通讯，也就是下图流程：

Master主进程给Worker子进程分发任务，通讯的方式用的就是单向管道的方式；

分发任务这块，可以有随机分发、轮流分发、计分板等多种方法，具体可以结合业务进行设计；

本节根据上述流程图进行一个简单的实现，假设分别有A、B、C三种任务，主进程使用轮流分发（Round-robin）把任务均匀地分配给子进程们；

在结构体process上得考虑一下，Master进程需要保存所有子进程的进程号、管道号；

 

/* Process struct */
typedef struct process
{
        char name[SIZE_NAME_NORMAL];                    /* Process name */
        pid_t pid;                                      /* Process id */
        int pipefd[2];                                  /* Connection between master/slave */
        size_t score;                                   /* Score record */
} process_t;
 
/* Program instance */
typedef struct instance
{
        char prg_name[SIZE_NAME_LONG];                  /* Program name with path */
        char cfg_name[SIZE_NAME_LONG];                  /* Configure name with path */
 
        u16 process_num;                                /* Sub process number */
        u16 process_idx;                                /* Current process index */
 
        struct process *proc;                           /* Process struct */
} instance_t;

进程池的初始化函数，根据给定的Worker进程数开启子进程；

 

int process_pool(instance_t *pinst, u16 process_num)
{
    int ret = FAILURE;
    int ix  = 0;
    int status = 0;
 
    if ( !pinst || !process_num ) {
        printf("NULL\n");
        goto _E1;
    }
 
    signal(SIGINT,  __sig_quit);
    signal(SIGTERM, __sig_quit);
 
    pinst->process_idx = 0;
    pinst->process_num = process_num;
    pinst->proc = (process_t *)calloc(process_num + 1, sizeof(process_t));
    if ( !pinst->proc ) {
        printf("Alloc process pool struct failed\n");
        goto _E1;
    }
 
    for ( ix = 1; ix <= process_num; ix++ ) {
 
        int bufsize = 1;
        ret = pipe(pinst->proc[ix].pipefd);
        if ( SUCCESS != ret ) {
            printf("socketpair\n");
            goto _E2;
        }
 
        printf("Setup worker#%u\n", ix);
 
        pinst->proc[ix].pid = fork();
        if ( pinst->proc[ix].pid < 0 ) {
            printf("fork\n");
            goto _E2;
        }
        else if ( pinst->proc[ix].pid > 0 ) {
            /* Father */
            CLOSE_FD(pinst->proc[ix].pipefd[0]);
            continue;
        }
        else {
            /* Child */
            CLOSE_FD(pinst->proc[ix].pipefd[1]);
            pinst->process_idx = ix;
            ret = __worker(pinst);
            goto _E2;
        }
    }
 
    ret = __master(pinst);
 
    /* Waiting workers */
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        waitpid(pinst->proc[ix].pid, &status, WNOHANG);
    }
 
_E2:
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        CLOSE_FD(pinst->proc[ix].pipefd[1]);
        CLOSE_FD(pinst->proc[ix].pipefd[0]);
    }
 
    FREE_POINTER(pinst->proc);
_E1:
    return ret;
}

然后就是Master Worker的实现，Master就是简单地进行一个事件分发，通过约定的协议"ABC"代表三种工作命令，“Q“代表退出进程；

 

static int __master(instance_t *pinst)
{
    int ret  = 0;
    int fd   = 0;
    int ix   = 0;
    int roll = 0;
 
    char c = 0;
 
#define __offset(pinst) ((pinst)->proc[(pinst)->process_idx])
#define __round_robin(pinst, roll) \
    ((pinst)->proc[((roll) % (pinst)->process_num) + 1].pipefd[1])
 
    printf("Master#%u setup\n", pinst->process_idx);
 
    for ( g_enable = 1; g_enable; ) {
 
        /* Get pipe fd by round-robin */
        fd = __round_robin(pinst, ++roll);
 
        c = 'A' + roll % 3; // 'A'/'B'/'C'
        ret = write(fd, &c, 1);
        if ( ret <= 0 ) {
            return FAILURE;
        }
        sleep(1);
    }
 
    /* Tell all workers to quit */
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        c = 'Q';
        write(__round_robin(pinst, ++roll), &c, 1);
    }
 
    printf("Master#%u shutdown\n", pinst->process_idx);
    return SUCCESS;
}
static int __worker(instance_t *pinst)
{
    int fd = __offset(pinst).pipefd[0];
    int ix = 0;
    ssize_t read_byte = FAILURE;
    char buffer[1024] = {0};
 
    printf("Worker#%u setup\n", pinst->process_idx);
    for ( g_enable = 1; g_enable; ) {
        read_byte = read(fd, buffer, sizeof(buffer));
        if ( read_byte <= 0 ) {
            if ( errno == EAGAIN || errno == EINTR ) {
                continue;
            }
            return FAILURE;
        }
 
        for ( ix = 0; ix < read_byte; ix++ ) {
            switch ( buffer[ix] ) {
                case 'A':
                case 'B':
                case 'C':
                    __offset(pinst).score += buffer[ix];
                    printf("Worker#%u Recv command: %c, score: %llu\n",
                            pinst->process_idx,
                            buffer[ix], __offset(pinst).score);
                    break;
 
                case 'Q':
                    printf("Quit\n");
                    g_enable = 0;
                    break;
 
                default:
                    break;
            }
        }
    }
 
    printf("Worker#%u shutdown\n", pinst->process_idx);
    return SUCCESS;
}

 

最后带一个main方法，考虑了进程释放的问题，在这个demo中使用信号对genable进行控制；

 

static u8 g_enable;                         /* Running flag */
static void __sig_quit(int sig)
{
    g_enable = 0;
}
 
 
int main(int argc, char *argv[])
{
    instance_t inst = {0};
 
    if ( argc < 2 ) {
        printf("Usage: \n\t%s < process number >\n", argv[0]);
        return EXIT_FAILURE;
    }
 
    return process_pool(&inst, atoi(argv[1]));
}

 

完整代码如下:

/***
 *根据上述流程图进行一个简单的实现，假设分别有A、B、C三种任务，主进程使用轮流分发（Round-robin）把任务均匀地分配给子进程们；
 *在结构体process上得考虑一下，Master进程需要保存所有子进程的进程号、管道号；
 *
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>


#define FAILURE -1
#define u8  unsigned char

#define u16 unsigned  short

#define SIZE_NAME_NORMAL 48

#define SIZE_NAME_LONG 48

#define SUCCESS 0

#define CLOSE_FD(x) (close(x))

#define FREE_POINTER(x) (free(x))
#define __offset(pinst) ((pinst)->proc[(pinst)->process_idx])

/* 写管道*/
#define __round_robin(pinst, roll) \
    ((pinst)->proc[((roll) % (pinst)->process_num) + 1].pipefd[1])
/***
 *本节根据上述流程图进行一个简单的实现，假设分别有A、B、C三种任务，主进程使用轮流分发（Round-robin）把任务均匀地分配给子进程们；
 *在结构体process上得考虑一下，Master进程需要保存所有子进程的进程号、管道号；
 *
 */

/* Process struct */
typedef struct process
{
    char name[SIZE_NAME_NORMAL];                    /* Process name */
    pid_t pid;                                      /* Process id */
    int pipefd[2];                                  /* Connection between master/slave */
    size_t score;                                   /* Score record */
} process_t;

/* Program instance */
typedef struct instance
{
    char prg_name[SIZE_NAME_LONG];                  /* Program name with path */
    char cfg_name[SIZE_NAME_LONG];                  /* Configure name with path */

    u16 process_num;                                /* Sub process number */
    u16 process_idx;                                /* Current process index */

    struct process *proc;                           /* Process struct */

} instance_t;


static u8 g_enable;                         /* Running flag */

static void __sig_quit(int sig)
{
    g_enable = 0;
}


static int __master(instance_t *pinst)
{
    int ret  = 0;
    int fd   = 0;
    int ix   = 0;
    int roll = 0;

    char c = 0;


    printf("Master#%u setup\n", pinst->process_idx);

    for ( g_enable = 1; g_enable; ) {

        /* Get pipe fd by round-robin */
        fd = __round_robin(pinst, ++roll);

        c = 'A' + roll % 3; // 'A'/'B'/'C'
        ret = write(fd, &c, 1);
        if ( ret <= 0 ) {
            return FAILURE;
        }
        sleep(1);
    }

    /* Tell all workers to quit */
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        c = 'Q';
        write(__round_robin(pinst, ++roll), &c, 1);
    }

    printf("Master#%u shutdown\n", pinst->process_idx);
    return SUCCESS;
}


static int __worker(instance_t *pinst)
{
    int fd = __offset(pinst).pipefd[0];
    int ix = 0;
    ssize_t read_byte = FAILURE;
    char buffer[1024] = {0};

    printf("Worker#%u setup\n", pinst->process_idx);

    for ( g_enable = 1; g_enable; ) {
        printf("work read front......\n");
        read_byte = read(fd, buffer, sizeof(buffer)); /* 读管道会阻塞*/
        printf("work read after......\n");
        if ( read_byte <= 0 ) {
            if ( errno == EAGAIN || errno == EINTR ) {
                continue;
            }
            return FAILURE;
        }

        for ( ix = 0; ix < read_byte; ix++ ) {
            switch ( buffer[ix] ) {
                case 'A':
                case 'B':
                case 'C':
                    __offset(pinst).score += buffer[ix];
                    printf("Worker#%u Recv command: %c, score: %llu\n",
                           pinst->process_idx,
                           buffer[ix], __offset(pinst).score);
                    break;

                case 'Q':
                    printf("Quit\n");
                    g_enable = 0;
                    break;

                default:
                    break;
            }
        }
    }

    printf("Worker#%u shutdown\n", pinst->process_idx);
    return SUCCESS;
}



int process_pool(instance_t *pinst, u16 process_num)
{
    int ret = FAILURE;
    int ix  = 0;
    int status = 0;

    if ( !pinst || !process_num ) {
        printf("NULL\n");
        goto _E1;
    }
    /**
     * SIGINT ctrl+c 终止进程
     */
    signal(SIGINT,  __sig_quit);
    /** SIGTERM 程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和
     *处理. 通常用来要求程序自己正常退出. shell命令kill缺省产生这
     *个信号. */

    signal(SIGTERM, __sig_quit);

    pinst->process_idx = 0;

    pinst->process_num = process_num;

    pinst->proc = (process_t *)calloc(process_num + 1, sizeof(process_t));

    if ( !pinst->proc ) {
        printf("Alloc process pool struct failed\n");
        goto _E1;
    }

    for ( ix = 1; ix <= process_num; ix++ ) {

        int bufsize = 1;
        /*fd[0]:读管道，fd[1]:写管道*/
        ret = pipe(pinst->proc[ix].pipefd);

        if ( SUCCESS != ret ) {
            printf("socketpair\n");
            goto _E2;
        }

        printf("Setup worker#%u\n", ix);

        pinst->proc[ix].pid = fork();

        if ( pinst->proc[ix].pid < 0 ) {
            printf("fork\n");
            goto _E2;
        }

        else if ( pinst->proc[ix].pid > 0 ) {
            /* Father process close read fd pipe */
            CLOSE_FD(pinst->proc[ix].pipefd[0]);
            printf(".......\n");
            continue;
        }
        else {
            /* Child process close write fd pipe */
            CLOSE_FD(pinst->proc[ix].pipefd[1]);
            printf("xxxxxxxx\n");
            pinst->process_idx = ix;
            ret = __worker(pinst);
            goto _E2;
        }
    }

    ret = __master(pinst);

    /* Waiting workers */
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        waitpid(pinst->proc[ix].pid, &status, WNOHANG);
    }

    _E2:
    for ( ix = 1; ix <= pinst->process_num; ix++ ) {
        CLOSE_FD(pinst->proc[ix].pipefd[1]);
        CLOSE_FD(pinst->proc[ix].pipefd[0]);
    }

    FREE_POINTER(pinst->proc);
    _E1:
    return ret;
}


int main(int argc, char *argv[])
{
    instance_t inst = {0};  /*实例结构体*/

    if ( argc < 2 ) {
        printf("Usage: \n\t%s < process number >\n", argv[0]);
        return EXIT_FAILURE;
    }

    return process_pool(&inst, atoi(argv[1]));
}

 

jenie
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程池的实现
td_731722411的博客
05-14 848
今天总结了下进程池，和大家分享一下，感觉初学者因该能比较好理解。 进程池，顾名思义是一个装有进程的池子，池子有固定大小，也就是工作进程的数量，进程池的工作就是管理它自己这个池子。 进程池基本工作机制是：当进程池启动时，就创建规定数量的进程（自己设定合适数量），等待在那里；当有任务来的时候，进程池分配任务给空闲进程，空闲进程-->工作进 程；当工作进程完成所分配任务后，进程池回收空闲进程，工作
线程池原理及C语言实现
qq_40726202的博客
09-13 630
一、简介 1、线程池的概念 线程池本质就是线程的集合。 进程在启动时便创建一定数量的线程，在没有任务时，这些线程处于空闲状态。程序在运行时可将任务通过任务队列传递给线程池，这是池中的线程便会启动一个来执行该任务，任务执行完后，启动的线程不会被销毁，而是重新返回空闲状态，等待下一个任务的执行。 2、线程池的优势 在多线程运行的程序中，如果不断地创建和销毁线程，会过度消耗系统资源，内核开销较大。并且过度切换线程会带来一定的危险，从而增加系统崩溃的可能性。 线程池会维护相对稳定的线程数，减少了频繁创建、销毁线程带
在C语言中以编程的方式获取函数名
07-29
仅仅为了获取函数名，就在函数体中嵌入硬编码的字符串，这种方法单调乏味还易导致错误，不如看一下怎样使用新的C99特性，在程序运行时获取函数名吧。
Linux--构建进程池
2301_76618602的博客
05-28 1069
如果我们是关一个等待一个，那么第一个信道，只会关闭一个读端，但还有其它的读端，这就会发生进程阻塞，导致管道文件一直在等待读取，无法被释放；如果统一的关闭读端，那么当关闭到最后一个信道的时候，最后一个信道读端只有一个，管道文件会被释放，然后就会递归式的逆向关闭其它信道的所有读端，最后将所有的管道文件释放，父进程只需要一 一等待，就能回收所有子进程了。下面函数的主要逻辑是创建多个管道和相应的子进程，每个子进程都将从它自己的管道中读取数据，而父进程则保留管道的写端以便后续向子进程发送数据。，然后关闭读端并退出。
稍微研究一下就能看懂的进程池设计
IT说人话 的专栏
03-02 222
池 (Pool) 的概念被广泛地应用于软件开发领域，可以明显地提供应用的响应速度、改善效率、提供资源利用率。应用通过豢养一批空闲的 “工人”，”任务“来临时可以及时响应，避免了再次雇佣工人的消耗。此处的”工人“概念可以具体为进程（进程池）、线程（线程池）、连接（连接池）、内存（内存池）等。因为网络服务器在多进程模型下，是以操作系统申请资源为手段，以进程为载体来对外提供服务的。故，进程池是一种服务器后台提供服务或者网络功能的常见模型，主要目标是减少请求到来之时，才让操作系统创建进程进而对外提供服务的成本。
进程池技术实现
Pinkmanabcd的博客
07-15 677
多进程 优点： 可以使用计算机多核，进行任务的并发执行，提高执行效率 空间独立，数据安全 运行不受其他进程影响，创建方便 缺点： 进程的创建和删除消耗的系统资源较多 进程池技术 1、产生原因： 如果有大量任务需要多进程完成，则可能需要频繁的创建和删除进程，给计算机带来较多的资源消耗 。 原理： 创建适当的进程放入进程池，用来处理待处理事件，处理完 毕后进程不销毁，仍然在进程...
【Python随笔】python进程池ProcessPoolExecutor的用法与实现分析
热门推荐
HiKariのTechLab
06-08 3万+
在python开发期间，由于GIL的原因，不能直接采用并行的方式处理代码逻辑。在multiprocessing库的支持下，python程序能够启动子进程执行特定的任务，但子进程的管理也成为了问题。为了简化用户开发成本，python在concurrent.futures下内置了ProcessPoolExecutor这一数据结构，实现了简单的进程管理及任务调度。如果没有特别的需求，开发者只需要用ProcessPoolExecutor即可实现并行执行任务。因此，本文简单对ProcessPoolExecutor的实
c语言学习进程及练习
weixin_73273440的博客
08-23 1572
c语言学习进程
使用c语言实现的死锁检测组件.zip
最新发布
06-14
本教程将通过C语言来实现一个死锁检测组件，这对于理解死锁原理以及如何预防和解决死锁问题具有极大的帮助。 首先，我们要了解死锁的基本条件：互斥条件、占有并等待、无剥夺和循环等待。互斥条件意味着资源只能由...
内存池实现mem-pool
09-02
总的来说，"mem-pool"项目是一个实践性的Linux C语言内存池实现，它提供了一个理解和掌握内存池工作原理的平台，对于深入理解内存管理和优化具有重要意义。通过学习和分析这个项目，开发者能够更好地运用内存池技术...
队列的C语言优化实现
01-06
- 在链表实现中，可以使用内存池技术减少内存碎片，提高内存分配和释放的速度。 5. 并发环境下的队列： - 在多线程环境下，需要使用锁或信号量来保证线程安全，如互斥锁（mutex）保护队列操作。 - 可以使用条件...
C语言 Linux Nginx 线程池
06-22
总之，C语言 Linux Nginx 线程池的结合是高性能服务器开发的重要一环，它涉及到操作系统原理、网络编程和并发控制等多个领域的知识，对提升服务器性能和稳定性有着显著的作用。通过学习和实践，开发者能够构建出更加...
C语言接口与实现
07-14
7. 并发编程：在C语言中，如何实现线程和进程，以及同步和互斥的概念。可能涉及信号量、锁、条件变量等并发控制机制。 8. 性能优化：讨论代码优化技巧，如循环展开、减少函数调用开销、内存池等，以提高程序运行...
Linux多进程(五) 进程池 C++实现
Lyajpunov的博客
04-26 1017
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
C++实现一个简单的进程池
m0_74824254的博客
04-13 1025
匿名管道实现进程池，命名管道实现进程池。 ------代码加思路详解
linux c语言 进程池实现,Linux线程池(C语言描述)
weixin_39952074的博客
05-01 192
创建线程或者进程的开销是很大的，为了防止频繁的创建线程，提高程序的运行效率，往往都会建立一个线程池用于多线程程序的调度下面的程序就是完整的线程池实现，主要采用互斥量和条件变量实现同步首先定义头文件threadpool.h在该文件中定义了线程池的数据结构和所有的函数#ifndef THREADPOOL_H_#define THREADPOOL_H_#include #include #include...
c半同步半异步进程池模型之cgi服务器
lkness的博客
09-17 1125
对半同步半异步进程池模型垂涎已久，这次中秋放假撸了下代码，代码写了几个模块，分别是： util：封装了套接字创建、unix族socket管道创建、中断信号、简单屏幕输出(可自行替换为日志文件输出) epoll_wrapper：封装了epoll相关操作包括创建epfd、添加epoll监听事件、删除epoll监听事件 myhshappool(我的半同步半异步进程池 - -!…)：封装了进程池初始化
LIUNX系统编程：进程池的实现
W2155的博客
05-06 447
每一个可执行程序，在被执行前都要转化为进程，操作系统都要为其创建PCB，地址空间，页表，构建映射关系，进程池就是创建进程时，创建很多个进程，如果要执行程序，就直接使用创建好的进程。就像一次性创建5个进程，肯定是比一次创建一个创建5次的效率更好的，将任务均匀的分配给进程执行。
进程池(multiprocess.Pool)
淘小欣的博客
02-19 6618
进程池(multiprocess.Pool) 一、进程池概念 1.什么是进程池? ????进程池是资源进程, 管理进程组成的技术的应用. 2.为什么要有进程池? ????忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。 ????那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？ ????首先，创建进程需要消耗时间，销毁进程也需要消耗时间。 ????第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。 ????因此我们不能无限制的根据任务去开
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值