linux线程池分析

一. 线程池学习文件

pool_test/  -> 线程池函数接口实现源码，简单实例。

系统编程项目接口设计说明书.doc  -> 详细说明了线程池各个函数的头文件/原型/参数/返回值..。

线程池模型.jpg  -> 帮助大家理解线程池原理。

二. 学习线程池实现过程？

1. 什么是线程池？

线程池就是多个线程组合起来的一个集合，当有任务时，线程就会处理任务，当没有任务时，线程休息。

2. 分析线程池源码

thread_pool.c  -> 线程池函数接口源码

thread_pool.h  -> 函数接口声明/结构体声明/头文件..

===========================================================

thread_pool.h

 

#define MAX_WAITING_TASKS  1000

   -> 最大的任务等待个数

#define MAX_ACTIVE_THREADS 20     -> 最大线程个数

 

0）任务节点结构体

struct task

{

      

       void *(*do_task)(void *arg);  -> 任务函数

       void *arg;

 

                    -> 任务函数的参数

       struct task *next;         -> 指向下一个任务节点的指针

};

 

1）线程池模型

typedef struct thread_pool

{

      

       pthread_mutex_t lock;

  -> 互斥锁

       pthread_cond_t  cond;

  -> 条件变量   

       bool shutdown;

              -> 线程池关闭标识符号  true->关闭   false->未关闭

       struct task *task_list;

-> 任务队列的头文件

       pthread_t *tids;

       -> 存放线程TID号空间地址     

       unsigned max_waiting_tasks;

 -> 最大的等待任务的个数     

       unsigned waiting_tasks;  -> 当前等待任务的个数

      

       unsigned active_threads;

  -> 当前线程池中线程的个数

}thread_pool;

2）初始化线程池函数模型

bool init_pool(thread_pool *pool, unsigned int threads_number);

3）线程处理函数

void *routine(void *arg)

4）添加任务函数

bool add_task(thread_pool *pool,void *(*do_task)(void *arg), void *arg)

===========================================================

thread_pool.c

1）初始化线程池函数源码

 

2）线程处理函数源码

 

3）添加任务函数源码

源码：

头文件：

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include <errno.h>
#include <pthread.h>

#define MAX_WAITING_TASKS    1000
#define MAX_ACTIVE_THREADS    20

struct task
{
    void *(*do_task)(void *arg);
    void *arg;

    struct task *next;
};

typedef struct thread_pool
{
    pthread_mutex_t lock;
    pthread_cond_t  cond;
    bool shutdown;
    struct task *task_list;
    pthread_t *tids;
    unsigned max_waiting_tasks;
    unsigned waiting_tasks;
    unsigned active_threads;
}thread_pool;


bool init_pool(thread_pool *pool, unsigned int threads_number);
bool add_task(thread_pool *pool, void *(*do_task)(void *arg), void *task);
int  add_thread(thread_pool *pool, unsigned int additional_threads_number);
int  remove_thread(thread_pool *pool, unsigned int removing_threads_number);
bool destroy_pool(thread_pool *pool);

void *routine(void *arg);


#endif

功能函数：

#include "thread_pool.h"

void handler(void *arg)
{
    printf("[%u] is ended.\n",
        (unsigned)pthread_self());

    //解锁！
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}

void *routine(void *arg)
{
    //接住线程池的地址
    thread_pool *pool = (thread_pool *)arg;
    struct task *p;

    while(1)
    {
        //取消例程函数，将来线程上锁了，如果收到取消请求，那么先解锁，再退出
        pthread_cleanup_push(handler, (void *)&pool->lock);
        
        //任务队列是属于临界资源。
        //访问任务队列之前都必须上锁。
        pthread_mutex_lock(&pool->lock);
    
        //如果当前线程池未被关闭并且线程池中没有需要处理的任务时：
        while(pool->waiting_tasks == 0 && !pool->shutdown)
        {
            //那么就进入条件变量中等待！
            pthread_cond_wait(&pool->cond, &pool->lock);
        }
        
        //如果线程等待任务为0，并且线程池已经关闭了。
        if(pool->waiting_tasks == 0 && pool->shutdown == true)
        {    
            //解锁
            pthread_mutex_unlock(&pool->lock);    
            
            //走人
            pthread_exit(NULL); 
        }

        //有任务做，代表肯定不是空链表，拿任务p
        p = pool->task_list->next;
        pool->task_list->next = p->next;
        
        //当前等待的任务的个数-1
        pool->waiting_tasks--;

        //解锁
        pthread_mutex_unlock(&pool->lock);
        
        //删除线程取消例程函数
        pthread_cleanup_pop(0);
        
        //设置线程不可以响应取消。
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
        
        //执行任务节点中函数过程中，不希望被别人取消掉。
        (p->do_task)(p->arg);
        
        //设置为可以响应取消
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

        //释放任务节点p的内存空间
        free(p);
    }

    pthread_exit(NULL);
}

bool init_pool(thread_pool *pool, unsigned int threads_number)
{
    //1. 初始化互斥锁
    pthread_mutex_init(&pool->lock, NULL);
    
    //2. 初始化条件变量
    pthread_cond_init(&pool->cond, NULL);

    //3. 线程池关闭标志为未关闭
    pool->shutdown = false;
    
    //4. 为任务队列头节点申请空间
    pool->task_list = malloc(sizeof(struct task));
    
    //5. 为线程TID号申请空间
    pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);

    //错误判断
    if(pool->task_list == NULL || pool->tids == NULL)
    {
        perror("allocate memory error");
        return false;
    }

    //为任务队列头节点的指针域赋值NULL
    pool->task_list->next = NULL;
    
    //设置最大等待任务个数为1000
    pool->max_waiting_tasks = MAX_WAITING_TASKS;
    
    //设置当前等待任务的个数为0
    pool->waiting_tasks = 0;
    
    //设置当前线程池线程的个数
    pool->active_threads = threads_number;

    int i;
    //创建线程池中的子线程
    for(i=0; i<pool->active_threads; i++)
    {
        if(pthread_create(&((pool->tids)[i]), NULL,routine, (void *)pool) != 0)
        {
            perror("create threads error");
            return false;
        }
    }

    //初始化成功
    return true;
}

bool add_task(thread_pool *pool,void *(*do_task)(void *arg), void *arg)
{
    //为新节点申请内存空间
    struct task *new_task = malloc(sizeof(struct task));
    if(new_task == NULL)
    {
        perror("allocate memory error");
        return false;
    }
    
    //为新节点的数据域赋值
    new_task->do_task = do_task;  //函数
    new_task->arg = arg; //函数的参数
    
    //为新节点的指针域赋值
    new_task->next = NULL;  

    //访问任务队列前，先上锁！
    pthread_mutex_lock(&pool->lock);
    
    //如果当前等待任务个数>=1000，则添加任务失败！
    if(pool->waiting_tasks >= MAX_WAITING_TASKS)
    {
        //解锁
        pthread_mutex_unlock(&pool->lock);

        //输出错误信息
        fprintf(stderr, "too many tasks.\n");
        
        //释放刚刚初始化过的新节点
        free(new_task);

        return false;
    }
    
    //寻找任务队列的最后一个节点
    struct task *tmp = pool->task_list;
    while(tmp->next != NULL)
        tmp = tmp->next;
    
    //tmp->next = NULL;

    //把新节点尾插进去任务队列中
    tmp->next = new_task;
    
    //当前最大的等待任务的个数+1
    pool->waiting_tasks++;

    //解锁
    pthread_mutex_unlock(&pool->lock);

    //随机唤醒条件变量中其中一个线程起来就可以了。
    pthread_cond_signal(&pool->cond);
    
    return true;
}

int add_thread(thread_pool *pool, unsigned additional_threads)
{
    //如果新增0个线程
    if(additional_threads == 0)
        return 0; //直接返回0

    //添加后线程总数
    unsigned total_threads = 
            pool->active_threads + additional_threads;
                        
    int i, actual_increment = 0;
    
    //创建线程
    for(i = pool->active_threads;  
          i < total_threads && i < MAX_ACTIVE_THREADS;  
          i++) 
       {
        if(pthread_create(&((pool->tids)[i]),NULL, routine, (void *)pool) != 0)
        {
            perror("add threads error");
            if(actual_increment == 0) 
                return -1;

            break;
        }
        actual_increment++;  //真正创建的线程个数
    }

    //当前活跃的线程数 = 原来活跃的线程数 + 新实际创建的线程数
    pool->active_threads += actual_increment;
    
    return actual_increment;
}

     
int remove_thread(thread_pool *pool, unsigned int removing_threads)
{
    //如果需要删除0条线程
    if(removing_threads == 0)
        return pool->active_threads; //当前线程池活跃的线程个数

    //剩余的线程数 = 当前活跃的线程数 - 需要删除的线程。
    int remaining_threads = pool->active_threads - removing_threads;

    //线程池中至少有1条线程
    remaining_threads = remaining_threads > 0 ? remaining_threads : 1;

    int i;  
    for(i=pool->active_threads-1; i>remaining_threads-1; i--)
    {    
        errno = pthread_cancel(pool->tids[i]);
        if(errno != 0)
            break;
    }

    //如果取消失败，则函数返回-1
    if(i == pool->active_threads-1)
        return -1;
    else
    {
        //计算当前剩余实际的个数
        pool->active_threads = i+1;
        return i+1; //返回当前线程剩余的个数
    }
}


bool destroy_pool(thread_pool *pool)
{
    pool->shutdown = true; //当前线程池标志是关闭状态
    pthread_cond_broadcast(&pool->cond);
    int i;
    for(i=0; i<pool->active_threads; i++)
    {
        errno = pthread_join(pool->tids[i], NULL);

        if(errno != 0)
        {
            printf("join tids[%d] error: %s\n",
                    i, strerror(errno));
        }
    
        else
            printf("[%u] is joined\n", (unsigned)pool->tids[i]);
        
    }


    free(pool->task_list);
    free(pool->tids);
    free(pool);

    return true;
}

主函数：

#include "thread_pool.h"

void *mytask(void *arg) //线程的任务
{
    int n = (int)arg;

    //工作任务：余数是多少，就睡多少秒，睡完，任务就算完成
    printf("[%u][%s] ==> job will be done in %d sec...\n",
        (unsigned)pthread_self(), __FUNCTION__, n);

    sleep(n);

    printf("[%u][%s] ==> job done!\n",
        (unsigned)pthread_self(), __FUNCTION__);

    return NULL;
}

void *count_time(void *arg)
{
    int i = 0;
    while(1)
    {
        sleep(1);
        printf("sec: %d\n", ++i);
    }
}

int main(void)
{
    // 本线程用来显示当前流逝的秒数
    // 跟程序逻辑无关
    pthread_t a;
    pthread_create(&a, NULL, count_time, NULL);

    // 1, initialize the pool
    thread_pool *pool = malloc(sizeof(thread_pool));
    init_pool(pool, 2);
    //2个线程都在条件变量中睡眠

    // 2, throw tasks
    printf("throwing 3 tasks...\n");
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));

    // 3, check active threads number
    printf("current thread number: %d\n",
            remove_thread(pool, 0));//2
    sleep(9);

    // 4, throw tasks
    printf("throwing another 6 tasks...\n");
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    add_task(pool, mytask, (void *)(rand()%10));
    
    // 5, add threads
    add_thread(pool, 2);

    sleep(5);

    // 6, remove threads
    printf("remove 3 threads from the pool, "
           "current thread number: %d\n",
            remove_thread(pool, 3));

    // 7, destroy the pool
    destroy_pool(pool);
    return 0;
}