简单易用的线程池实现

0 前言

最近在写MySQL冷备server的一个模块，稍微接触到一点线程池的东西，自己也就想尝试写一个简单的线程池练练手。

这个线程池在创建时，即按照最大的线程数生成线程。

然后作业任务通过add_task接口往线程池中加入需要运行的任务，再调用线程池的run函数开始运行所有任务，每个线程从任务队列中读取任务，处理完一个任务后再读取新的任务，直到最终任务队列为空。

补充：再回头看这个设计，其实算不了线程池，最多算是多线程执行任务。

把所有的任务描述信息先加入到CThreadPool的任务队列里面，然后调用CThreadPool的run函数去创建指定数量的线程，每个线程互斥的从任务队列里面取出任务去执行。

1 线程池设计

简单描述如下（假设任务类名为CTasklet）：

1、CThreadPool<CTasklet> thread_pool(MAX_THREAD_NUM);

2、创建任务，并把任务加入到线程池

    CTasklet *pTask1 = new CTasklet();

    CTasklet *pTask2 = new CTasklet();

    ...

    thread_pool.add_task(pTask1);

    thread_pool.add_task(pTask2);

    ...

3、调用线程池的run方法开始执行任务

    thread_pool.run();

4、等待任务执行完成

    thread_pool.join_thread();

2 源码

下面给出完整的线程池代码

/*
 * file: thread_pool.h
 * desc: 简单的线程池，一次性初始化任务队列和线程池。
 * 
 */

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <pthread.h>
#include <vector>

using namespace std;

template<typename workType>
class CThreadPool
{
    public:
        typedef void * (thread_func)(void *);

        CThreadPool(int thread_num, size_t stack_size = 10485760);
        ~CThreadPool();

        // 向任务队列中添加任务
        int add_task(workType *pTask);

        // 创建新线程并执行
        int run();

        // 等待所有的线程执行结束
        int join_thread();

    private:
        int init_thread_attr();
        int destroy_thread_attr();

        int set_thread_stacksize(size_t stack_size);
        int set_thread_joinable();

    protected:
        // 线程池执行函数，必须为static
        static void start_routine(void *para);

    private:
        pthread_attr_t attr_;
        static pthread_mutex_t mutex_lock_;
        static list<workType *> list_task_;

        int thread_num_; // 最大线程数
        vector<pthread_t> thread_id_vec_;
};
#endif

#include "pthread_pool.h"

template<typename workType>
pthread_mutex_t CThreadPool<workType>::mutex_lock_;

template<typename workType>
list<workType*> CThreadPool<workType*>::list_task_;

template<typename workType>
CThreadPool<workType>::CThreadPool(int thread_num, size_t stack_size)
{
    thread_num_ = thread_num;
    pthread_mutex_init(&mutex_lock_, NULL);

    init_thread_attr();
    set_thread_stacksize(stack_size);
    set_thread_joinable();
}

template<typename workType>
CThreadPool<workType>::~CthreadPool()
{
    destroy_thread_attr();
}

template <typename workType>
int init_thread_attr()
{
    return pthread_attr_init(&m_attr); 
}

template <typename workType>
int CThreadPool<workType>::destroy_thread_attr()
{
    return pthread_attr_destroy(&attr_);
}

template <typename workType>
int CThreadPool<workType>::set_thread_stacksize(size_t stack_size)
{
    return pthread_attr_setstacksize(&attr_, stack_size);
}

template <typename workType>
int CThreadPool<workType>::set_thread_joinable()
{
    return pthread_attr_setdetachstate(&attr_, PTHREAD_CREATE_JOINABLE);
}

template <typename workType>
void CThreadPool<workType>::start_routine(void *para)
{
    workType *pWorkType = NULL;

    while (1) {
        pthread_mutex_lock(&mutex_lock_);

        if (list_task_.empty()) {
            pthread_mutex_unlock(mutex_lock_);
            return;
        }

        pWorkType = *(list_task_.begin());
        list_task_.pop_front();
        pthread_mutex_unlock(&mutex_lock_);

        pWorkType->run();
        delete pWorkType;
        pWorkType = NULL;
    }
}

template <typename workType>
int CThreadPool<workType>::add_task(workType *pTask)
{
    pthread_mutex_lock(&mutex_lock_);
    list_task_.push_back(pTask);
    pthread_mutex_unlock(&mutex_lock_);
    return 0;
}

template <typename workType>
int CThreadPool<workType>::run()
{
    int rc;
    pthread_t tid;
    for (int i = 0; i < thread_num_; ++i) {
        rc = pthread_create(&tid, &attr_, (thread_func)start_routine, NULL);
        thread_id_vec_.push_back(tid);
    }
    return rc;
}

template <typename workType>
int CThreadPool<workType>::join_thread()
{
    int rc = 0;
    vector<pthread_t>::iterator iter;
    for (iter = thread_id_vec_.begin(); iter != thread_id_vec_.end(); ++iter) {
        rc = pthread_join((*iter), NULL);
    }
    thread_id_vec_.clear();
    return rc;
}

测试代码如下

#include <unistd.h>

#include <iostream>
#include <list>

using namespace std;

class CTasklet
{
    public:
        CTasklet(int num) {
            num_ = num;
            cout << "CTasklet ctor create num: " << num_ << endl;
        }

        ~CTasklet() {
            cout << "CTasklet dtor delete num: " << num_ << endl;
        }

        int run() {
            cout << "CTasklet sleep begin: " << num_ << endl;
            sleep(num_);
            cout << "CTasklet sleep end: " << num_ << endl;
        }

    private:
        int num_;
};

#define MAX_THREAD_NUM 3
int main(int argc, char **argv)
{
    // Step1. 创建线程池
    CThreadPool<CTasklet> thread_pool(MAX_THREAD_NUM);

    // Step2. 创建任务，并加入到线程池中
    for (int i = 0; i < 6; ++i) {
        CTasklet *pTask = new CTasklet(i);
        thread_pool.add_task(pTask);
    }
    // Step3. 开始执行任务
    thread_pool.run();
    // Step4. 等待任务结束
    thread_pool.join_thread();

    return 0;

}

3 总结

上面的线程池属于最简单的一类线程池，即相当于程序运行时候就开启n个线程来执行任务。真正的线程池需要考虑的方面比较多，比如1、线程池中的线程数应该能动态变化；2、线程池能动态调度线程来运行任务，以达到均衡；3、线程池还应该能记录任务的运行时间，防止超时等等。

不过，起码我们已经开了个头，实现了一个简单的线程池，接下来，让我们在这个基础上一步步调整、完善。

PS:对于线程池的考虑，我能想到的有动态增减线程数、超时机制、负载均衡。不知道大家理解线程池还需要考虑什么场景。