Linux网络编程【四】：进程池、线程池原理及简单线程池源码分析

爱被打了一巴掌 2022-06-15 11:47 203阅读 0赞

进程池和线程池概述

进程池和线程池相似，所以这里我们以进程池为例进行介绍。如没有特殊声明，下面对进程池的讨论完全是用于线程池。

进程池是由服务器预先创建的一组子进程，这些子进程的数目在 3~10 个之间（当然这只是典型情况）。线程池中的线程数量应该和 CPU 数量差不多。  
进程池中的所有子进程都运行着相同的代码，并具有相同的属性，比如优先级、 PGID 等。  
当有新的任务来临时，主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程，选择一个已经存在的子进程的代价显得小得多。至于主进程选择哪个子进程来为新任务服务，则有两种方法：  
主进程使用某种算法来主动选择子进程。最简单、最常用的算法是随机算法和 Round Robin （轮流算法）。  
主进程和所有子进程通过一个共享的工作队列来同步，子进程都睡眠在该工作队列上。当有新的任务到来时，主进程将任务添加到工作队列中。这将唤醒正在等待任务的子进程，不过只有一个子进程将获得新任务的“接管权”，它可以从工作队列中取出任务并执行之，而其他子进程将继续睡眠在工作队列上。  
当选择好子进程后，主进程还需要使用某种通知机制来告诉目标子进程有新任务需要处理，并传递必要的数据。最简单的方式是，在父进程和子进程之间预先建立好一条管道，然后通过管道来实现所有的进程间通信。在父线程和子线程之间传递数据就要简单得多，因为我们可以把这些数据定义为全局，那么它们本身就是被所有线程共享的。  
综上所述，进程池的一般模型如下所示：

![SouthEast][]

应用场景：

线程池：

1、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。  
2、对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。  
3、接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，并出现"OutOfMemory"的错误。

下面是从网络下载学习的部分线程池（threadpool）源码：

thread.h

struct job
    {
        void* (*callback_function)(void *arg);    //线程回调函数
        void *arg;                                //回调函数参数
        struct job *next;
    };
    
    struct threadpool
    {
        int thread_num;                   //线程池中开启线程的个数
        int queue_max_num;                //队列中最大job的个数
        struct job *head;                 //指向job的头指针
        struct job *tail;                 //指向job的尾指针
        pthread_t *pthreads;              //线程池中所有线程的pthread_t
        pthread_mutex_t mutex;            //互斥信号量
        pthread_cond_t queue_empty;       //队列为空的条件变量
        pthread_cond_t queue_not_empty;   //队列不为空的条件变量
        pthread_cond_t queue_not_full;    //队列不为满的条件变量
        int queue_cur_num;                //队列当前的job个数
        int queue_close;                  //队列是否已经关闭
        int pool_close;                   //线程池是否已经关闭
    };
    
    //================================================================================================
    //函数名：                   threadpool_init
    //函数描述：                 初始化线程池
    //输入：                    [in] thread_num     线程池开启的线程个数
    //                         [in] queue_max_num  队列的最大job个数 
    //输出：                    无
    //返回：                    成功：线程池地址 失败：NULL
    //================================================================================================
    struct threadpool* threadpool_init(int thread_num, int queue_max_num);
    
    //================================================================================================
    //函数名：                    threadpool_add_job
    //函数描述：                  向线程池中添加任务
    //输入：                     [in] pool                  线程池地址
    //                          [in] callback_function     回调函数
    //                          [in] arg                     回调函数参数
    //输出：                     无
    //返回：                     成功：0 失败：-1
    //================================================================================================
    int threadpool_add_job(struct threadpool *pool, void* (*callback_function)(void *arg), void *arg);
    
    //================================================================================================
    //函数名：                    threadpool_destroy
    //函数描述：                   销毁线程池
    //输入：                      [in] pool                  线程池地址
    //输出：                      无
    //返回：                      成功：0 失败：-1
    //================================================================================================
    int threadpool_destroy(struct threadpool *pool);
    
    //================================================================================================
    //函数名：                    threadpool_function
    //函数描述：                  线程池中线程函数
    //输入：                     [in] arg                  线程池地址
    //输出：                     无  
    //返回：                     无
    //================================================================================================
    void* threadpool_function(void* arg);

threadpool.c

#include "threadpool.h"
    
    struct threadpool* threadpool_init(int thread_num, int queue_max_num)
    {
        struct threadpool *pool = NULL;
        do 
        {
            pool = malloc(sizeof(struct threadpool));
            if (NULL == pool)
            {
                printf("failed to malloc threadpool!\n");
                break;
            }
            pool->thread_num = thread_num;
            pool->queue_max_num = queue_max_num;
            pool->queue_cur_num = 0;
            pool->head = NULL;
            pool->tail = NULL;
            if (pthread_mutex_init(&(pool->mutex), NULL))
            {
                printf("failed to init mutex!\n");
                break;
            }
            if (pthread_cond_init(&(pool->queue_empty), NULL))
            {
                printf("failed to init queue_empty!\n");
                break;
            }
            if (pthread_cond_init(&(pool->queue_not_empty), NULL))
            {
                printf("failed to init queue_not_empty!\n");
                break;
            }
            if (pthread_cond_init(&(pool->queue_not_full), NULL))
            {
                printf("failed to init queue_not_full!\n");
                break;
            }
            pool->pthreads = malloc(sizeof(pthread_t) * thread_num);
            if (NULL == pool->pthreads)
            {
                printf("failed to malloc pthreads!\n");
                break;
            }
            pool->queue_close = 0;
            pool->pool_close = 0;
            int i;
            for (i = 0; i < pool->thread_num; ++i)
            {
                pthread_create(&(pool->pthreads[i]), NULL, threadpool_function, (void *)pool);
            }
            
            return pool;    
        } while (0);
        
        return NULL;
    }
    
    int threadpool_add_job(struct threadpool* pool, void* (*callback_function)(void *arg), void *arg)
    {
        assert(pool != NULL);
        assert(callback_function != NULL);
        assert(arg != NULL);
    
        pthread_mutex_lock(&(pool->mutex));
        while ((pool->queue_cur_num == pool->queue_max_num) && !(pool->queue_close || pool->pool_close))
        {
            pthread_cond_wait(&(pool->queue_not_full), &(pool->mutex));   //队列满的时候就等待
        }
        if (pool->queue_close || pool->pool_close)    //队列关闭或者线程池关闭就退出
        {
            pthread_mutex_unlock(&(pool->mutex));
            return -1;
        }
        struct job *pjob =(struct job*) malloc(sizeof(struct job));
        if (NULL == pjob)
        {
            pthread_mutex_unlock(&(pool->mutex));
            return -1;
        } 
        pjob->callback_function = callback_function;    
        pjob->arg = arg;
        pjob->next = NULL;
        if (pool->head == NULL)   
        {
            pool->head = pool->tail = pjob;
            pthread_cond_broadcast(&(pool->queue_not_empty));  //队列空的时候，有任务来时就通知线程池中的线程：队列非空
        }
        else
        {
            pool->tail->next = pjob;
            pool->tail = pjob;    
        }
        pool->queue_cur_num++;
        pthread_mutex_unlock(&(pool->mutex));
        return 0;
    }
    
    void* threadpool_function(void* arg)
    {
        struct threadpool *pool = (struct threadpool*)arg;
        struct job *pjob = NULL;
        while (1)  //死循环
        {
            pthread_mutex_lock(&(pool->mutex));
            while ((pool->queue_cur_num == 0) && !pool->pool_close)   //队列为空时，就等待队列非空
            {
                pthread_cond_wait(&(pool->queue_not_empty), &(pool->mutex));
            }
            if (pool->pool_close)   //线程池关闭，线程就退出
            {
                pthread_mutex_unlock(&(pool->mutex));
                pthread_exit(NULL);
            }
            pool->queue_cur_num--;
            pjob = pool->head;
            if (pool->queue_cur_num == 0)
            {
                pool->head = pool->tail = NULL;
            }
            else 
            {
                pool->head = pjob->next;
            }
            if (pool->queue_cur_num == 0)
            {
                pthread_cond_signal(&(pool->queue_empty));        //队列为空，就可以通知threadpool_destroy函数，销毁线程函数
            }
            if (pool->queue_cur_num == pool->queue_max_num - 1)
            {
                pthread_cond_broadcast(&(pool->queue_not_full));  //队列非满，就可以通知threadpool_add_job函数，添加新任务
            }
            pthread_mutex_unlock(&(pool->mutex));
            
            (*(pjob->callback_function))(pjob->arg);   //线程真正要做的工作，回调函数的调用
            free(pjob);
            pjob = NULL;    
        }
    }
    int threadpool_destroy(struct threadpool *pool)
    {
        assert(pool != NULL);
        pthread_mutex_lock(&(pool->mutex));
        if (pool->queue_close || pool->pool_close)   //线程池已经退出了，就直接返回
        {
            pthread_mutex_unlock(&(pool->mutex));
            return -1;
        }
        
        pool->queue_close = 1;        //置队列关闭标志
        while (pool->queue_cur_num != 0)
        {
            pthread_cond_wait(&(pool->queue_empty), &(pool->mutex));  //等待队列为空
        }    
        
        pool->pool_close = 1;      //置线程池关闭标志
        pthread_mutex_unlock(&(pool->mutex));
        pthread_cond_broadcast(&(pool->queue_not_empty));  //唤醒线程池中正在阻塞的线程
        pthread_cond_broadcast(&(pool->queue_not_full));   //唤醒添加任务的threadpool_add_job函数
        int i;
        for (i = 0; i < pool->thread_num; ++i)
        {
            pthread_join(pool->pthreads[i], NULL);    //等待线程池的所有线程执行完毕
        }
        
        pthread_mutex_destroy(&(pool->mutex));          //清理资源
        pthread_cond_destroy(&(pool->queue_empty));
        pthread_cond_destroy(&(pool->queue_not_empty));   
        pthread_cond_destroy(&(pool->queue_not_full));    
        free(pool->pthreads);
        struct job *p;
        while (pool->head != NULL)
        {
            p = pool->head;
            pool->head = p->next;
            free(p);
        }
        free(pool);
        return 0;
    }

main.c

[SouthEast]: /images/20220615/0d4605b6a1af4a10a9291211c320df82.png