简单Linux C线程池

最新推荐文章于 2024-06-16 22:07:17 发布

至简电子

最新推荐文章于 2024-06-16 22:07:17 发布

阅读量139

点赞数 2

分类专栏： # linux

原文链接：www.baidu.com

版权

linux 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

　　线程池就是为了解决上述问题的，它的实现原理是这样的：在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中这些线程都是处于阻塞状态，这些线程只占一点内存，不占用CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源。

　　下面是一个简单线程池的实现，这个线程池的代码是我参考网上的一个例子实现的，由于找不到出处了，就没办法注明参考自哪里了它的方案是这样的：程序启动之前，初始化线程池，启动线程池中的线程，由于还没有任务到来，线程池中的所有线程都处在阻塞状态，当一有任务到达就从线程池中取出一个空闲线程处理，如果所有的线程都处于工作状态，就添加到队列，进行排队。如果队列中的任务个数大于队列的所能容纳的最大数量，那就不能添加任务到队列中，只能等待队列不满才能添加任务到队列中。

　　主要由两个文件组成一个threadpool.h头文件和一个threadpool.c源文件组成。源码中已有重要的注释，就不加以分析了。

　　threadpool.h文件：

#include <pthread.h>
结构工作
{
    void *（* callback_function）（void * arg）; //线程回调函数
    void * arg; //回调函数参数
    struct job * next;
};

结构线程池
{
    int thread_num; //线程池中开启线程的个数
    int queue_max_num; //队列中最大的工作的个数
    struct job * head; //指向工作的头指针
    struct job * tail; //指向任务的尾指针
    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; //队列当前的任务个数
    int queue_close; //队列是否已经关闭
    int pool_close; //线程池是否已经关闭
};

// ================================================ ================================================
//函数名：threadpool_init
//函数描述：初始化线程池
//输入：[in] thread_num线程池开启的线程个数
// [in] queue_max_num队列的最大工作个数 
//输出：无
//返回：成功：线程池地址失败：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）;
结构工作
{
    void *（* callback_function）（void * arg）; //线程回调函数
    void * arg; //回调函数参数
    struct job * next;
};

结构线程池
{
    int thread_num; //线程池中开启线程的个数
    int queue_max_num; //队列中最大的工作的个数
    struct job * head; //指向工作的头指针
    struct job * tail; //指向任务的尾指针
    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; //队列当前的任务个数
    int queue_close; //队列是否已经关闭
    int pool_close; //线程池是否已经关闭
};

// ================================================ ================================================
//函数名：threadpool_init
//函数描述：初始化线程池
//输入：[in] thread_num线程池开启的线程个数
// [in] queue_max_num队列的最大工作个数 
//输出：无
//返回：成功：线程池地址失败：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.h头文件和一个threadpool.c源文件组成。源码中已有重要的注释，就不加以分析了。

　　threadpool.h文件：

　threadpool.c文件：

#include“threadpool.h”
的#include <stdlib.h>中
的#include <string.h>的
#include <stdio.h> 
的#include <pthread.h>
#include <assert.h>
#include“threadpool.h”

struct threadpool * threadpool_init（int thread_num，int queue_max_num）
{
    struct threadpool * pool = NULL;
    做 
    {
        pool = malloc（sizeof（struct threadpool））;
        如果（NULL ==池）
        {
            printf（“malloc threadpool！\ n”）;
            打破;
        }
        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（“无法启动互斥！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_empty），NULL））
        {
            printf（“无法启动queue_empty！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_not_empty），NULL））
        {
            printf（“无法启动queue_not_empty！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_not_full），NULL））
        {
            printf（“无法启动queue_not_full！\ n”）;
            打破;
        }
        pool-> pthreads = malloc（sizeof（pthread_t）* thread_num）;
        如果（NULL == pool-> pthreads）
        {
            printf（“无法使用malloc pthreads！\ n”）;
            打破;
        }
        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）;
        }
        
        返回池;    
    （0）;
    
    返回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->互斥））;
    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->互斥））;
        返回-1;
    }
    struct job * pjob =（struct job *）malloc（sizeof（struct job））;
    如果（NULL == pjob）
    {
        调用pthread_mutex_unlock（＆（pool->互斥））;
        返回-1;
    } 
    pjob-> callback_function = callback_function;    
    pjob-> arg = arg;
    pjob-> next = NULL;
    如果（pool-> head == NULL）   
    {
        pool-> head = pool-> tail = pjob;
        调用pthread_cond_broadcast（＆（pool-> queue_not_empty））; //队列空的时候，有任务来时就通知线程池中的线程：队列非空
    }
    其他
    {
        pool-> tail-> next = pjob;
        pool-> tail = pjob;    
    }
    pool-> queue_cur_num ++;
    调用pthread_mutex_unlock（＆（pool->互斥））;
    返回0;
}

void * threadpool_function（void * arg）
{
    struct threadpool * pool =（struct threadpool *）arg;
    struct job * pjob = NULL;
    while（1）//死循环
    {
        的pthread_mutex_lock（＆（pool->互斥））;
        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->互斥））;
            了pthread_exit（NULL）;
        }
        pool-> queue_cur_num--;
        pjob = pool-> head;
        如果（pool-> queue_cur_num == 0）
        {
            pool-> head = pool-> tail = NULL;
        }
        其他 
        {
            pool-> head = pjob-> next;
        }
        如果（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->互斥））;
        
        （*（pjob-> CALLBACK_FUNCTION））（pjob-> ARG）; //线程真正要做的工作，回调函数的调用
        自由（pjob）;
        pjob = NULL;    
    }
}
int threadpool_destroy（结构线程池*池）
{
    assert（pool！= NULL）;
    的pthread_mutex_lock（＆（pool->互斥））;
    if（pool-> queue_close || pool-> pool_close）//线程池已经退出了，就直接返回
    {
        调用pthread_mutex_unlock（＆（pool->互斥））;
        返回-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->互斥））;
    调用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->互斥））; //清理资源
    pthread_cond_destroy（＆（pool-> queue_empty））;
    pthread_cond_destroy（＆（pool-> queue_not_empty））;   
    pthread_cond_destroy（＆（pool-> queue_not_full））;    
    自由（pool->并行线程）;
    struct job * p;
    while（pool-> head！= NULL）
    {
        p = pool-> head;
        pool-> head = p-> next;
        自由（P）;
    }
    免费（池）;
    返回0;
}
的#include <stdlib.h>中
的#include <string.h>的
#include <stdio.h> 
的#include <pthread.h>
#include <assert.h>
#include“threadpool.h”

struct threadpool * threadpool_init（int thread_num，int queue_max_num）
{
    struct threadpool * pool = NULL;
    做 
    {
        pool = malloc（sizeof（struct threadpool））;
        如果（NULL ==池）
        {
            printf（“malloc threadpool！\ n”）;
            打破;
        }
        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（“无法启动互斥！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_empty），NULL））
        {
            printf（“无法启动queue_empty！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_not_empty），NULL））
        {
            printf（“无法启动queue_not_empty！\ n”）;
            打破;
        }
        if（pthread_cond_init（＆（pool-> queue_not_full），NULL））
        {
            printf（“无法启动queue_not_full！\ n”）;
            打破;
        }
        pool-> pthreads = malloc（sizeof（pthread_t）* thread_num）;
        如果（NULL == pool-> pthreads）
        {
            printf（“无法使用malloc pthreads！\ n”）;
            打破;
        }
        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）;
        }
        
        返回池;    
    （0）;
    
    返回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->互斥））;
    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->互斥））;
        返回-1;
    }
    struct job * pjob =（struct job *）malloc（sizeof（struct job））;
    如果（NULL == pjob）
    {
        调用pthread_mutex_unlock（＆（pool->互斥））;
        返回-1;
    } 
    pjob-> callback_function = callback_function;    
    pjob-> arg = arg;
    pjob-> next = NULL;
    如果（pool-> head == NULL）   
    {
        pool-> head = pool-> tail = pjob;
        调用pthread_cond_broadcast（＆（pool-> queue_not_empty））; //队列空的时候，有任务来时就通知线程池中的线程：队列非空
    }
    其他
    {
        pool-> tail-> next = pjob;
        pool-> tail = pjob;    
    }
    pool-> queue_cur_num ++;
    调用pthread_mutex_unlock（＆（pool->互斥））;
    返回0;
}

void * threadpool_function（void * arg）
{
    struct threadpool * pool =（struct threadpool *）arg;
    struct job * pjob = NULL;
    while（1）//死循环
    {
        的pthread_mutex_lock（＆（pool->互斥））;
        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->互斥））;
            了pthread_exit（NULL）;
        }
        pool-> queue_cur_num--;
        pjob = pool-> head;
        如果（pool-> queue_cur_num == 0）
        {
            pool-> head = pool-> tail = NULL;
        }
        其他 
        {
            pool-> head = pjob-> next;
        }
        如果（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->互斥））;
        
        （*（pjob-> CALLBACK_FUNCTION））（pjob-> ARG）; //线程真正要做的工作，回调函数的调用
        自由（pjob）;
        pjob = NULL;    
    }
}
int threadpool_destroy（结构线程池*池）
{
    assert（pool！= NULL）;
    的pthread_mutex_lock（＆（pool->互斥））;
    if（pool-> queue_close || pool-> pool_close）//线程池已经退出了，就直接返回
    {
        调用pthread_mutex_unlock（＆（pool->互斥））;
        返回-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->互斥））;
    调用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->互斥））; //清理资源
    pthread_cond_destroy（＆（pool-> queue_empty））;
    pthread_cond_destroy（＆（pool-> queue_not_empty））;   
    pthread_cond_destroy（＆（pool-> queue_not_full））;    
    自由（pool->并行线程）;
    struct job * p;
    while（pool-> head！= NULL）
    {
        p = pool-> head;
        pool-> head = p-> next;
        自由（P）;
    }
    免费（池）;
    返回0;
}

测试文件的main.c文件：

#include“threadpool.h”
#include <stdio.h> 
void * work（void * arg）
{
    char * p =（char *）arg;
    printf（“threadpool callback fuction：％s。\ n”，p）;
    睡眠（1）;
}

int main（void）
{
    struct threadpool * pool = threadpool_init（10，20）;
    threadpool_add_job（pool，work，“1”）;
    threadpool_add_job（pool，work，“2”）;
    threadpool_add_job（pool，work，“3”）;
    threadpool_add_job（pool，work，“4”）;
    threadpool_add_job（pool，work，“5”）;
    threadpool_add_job（pool，work，“6”）;
    threadpool_add_job（pool，work，“7”）;
    threadpool_add_job（pool，work，“8”）;
    threadpool_add_job（pool，work，“9”）;
    threadpool_add_job（pool，work，“10”）;
    threadpool_add_job（pool，work，“11”）;
    threadpool_add_job（pool，work，“12”）;
    threadpool_add_job（pool，work，“13”）;
    threadpool_add_job（pool，work，“14”）;
    threadpool_add_job（pool，work，“15”）;
    threadpool_add_job（pool，work，“16”）;
    threadpool_add_job（pool，work，“17”）;
    threadpool_add_job（pool，work，“18”）;
    threadpool_add_job（pool，work，“19”）;
    threadpool_add_job（pool，work，“20”）;
    threadpool_add_job（pool，work，“21”）;
    threadpool_add_job（pool，work，“22”）;
    threadpool_add_job（pool，work，“23”）;
    threadpool_add_job（pool，work，“24”）;
    threadpool_add_job（pool，work，“25”）;
    threadpool_add_job（pool，work，“26”）;
    threadpool_add_job（pool，work，“27”）;
    threadpool_add_job（pool，work，“28”）;
    threadpool_add_job（pool，work，“29”）;
    threadpool_add_job（pool，work，“30”）;
    threadpool_add_job（pool，work，“31”）;
    threadpool_add_job（pool，work，“32”）;
    threadpool_add_job（pool，work，“33”）;
    threadpool_add_job（pool，work，“34”）;
    threadpool_add_job（pool，work，“35”）;
    threadpool_add_job（pool，work，“36”）;
    threadpool_add_job（pool，work，“37”）;
    threadpool_add_job（pool，work，“38”）;
    threadpool_add_job（pool，work，“39”）;
    threadpool_add_job（pool，work，“40”）;

    睡眠（5）;
    threadpool_destroy（池）;
    返回0;
}
#include <stdio.h> 
void * work（void * arg）
{
    char * p =（char *）arg;
    printf（“threadpool callback fuction：％s。\ n”，p）;
    睡眠（1）;
}

int main（void）
{
    struct threadpool * pool = threadpool_init（10，20）;
    threadpool_add_job（pool，work，“1”）;
    threadpool_add_job（pool，work，“2”）;
    threadpool_add_job（pool，work，“3”）;
    threadpool_add_job（pool，work，“4”）;
    threadpool_add_job（pool，work，“5”）;
    threadpool_add_job（pool，work，“6”）;
    threadpool_add_job（pool，work，“7”）;
    threadpool_add_job（pool，work，“8”）;
    threadpool_add_job（pool，work，“9”）;
    threadpool_add_job（pool，work，“10”）;
    threadpool_add_job（pool，work，“11”）;
    threadpool_add_job（pool，work，“12”）;
    threadpool_add_job（pool，work，“13”）;
    threadpool_add_job（pool，work，“14”）;
    threadpool_add_job（pool，work，“15”）;
    threadpool_add_job（pool，work，“16”）;
    threadpool_add_job（pool，work，“17”）;
    threadpool_add_job（pool，work，“18”）;
    threadpool_add_job（pool，work，“19”）;
    threadpool_add_job（pool，work，“20”）;
    threadpool_add_job（pool，work，“21”）;
    threadpool_add_job（pool，work，“22”）;
    threadpool_add_job（pool，work，“23”）;
    threadpool_add_job（pool，work，“24”）;
    threadpool_add_job（pool，work，“25”）;
    threadpool_add_job（pool，work，“26”）;
    threadpool_add_job（pool，work，“27”）;
    threadpool_add_job（pool，work，“28”）;
    threadpool_add_job（pool，work，“29”）;
    threadpool_add_job（pool，work，“30”）;
    threadpool_add_job（pool，work，“31”）;
    threadpool_add_job（pool，work，“32”）;
    threadpool_add_job（pool，work，“33”）;
    threadpool_add_job（pool，work，“34”）;
    threadpool_add_job（pool，work，“35”）;
    threadpool_add_job（pool，work，“36”）;
    threadpool_add_job（pool，work，“37”）;
    threadpool_add_job（pool，work，“38”）;
    threadpool_add_job（pool，work，“39”）;
    threadpool_add_job（pool，work，“40”）;

    睡眠（5）;
    threadpool_destroy（池）;
    返回0;
}