线程池的理解与实现

线程池的代码实现：

线程池 = 大量的线程+线程安全的对列

1. 线程池：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
2. 线程池的实现：

// 描    述：在这个demo中实现一个线程池类供外部使用 
//      实现一个线程池任务类 
//      实现一个线程池类
//      通过让用户传入要处理的数据以及方法的方式完全与外部解耦和

#include <cstdio>
#include <iostream>
#include <queue>
#include <stdlib.h>
#include <pthread.h>

#include <unistd.h>
#include <time.h>

typedef void (*task_handler_t) (int arg);
class ThreadTask
{
    public:
        ThreadTask() {}
        ThreadTask(const int &data, task_handler_t handler):
        _data(data), _handler(handler){  }
        void SetTask(const int &data, task_handler_t handler) {
            _data = data;
            _handler = handler;
        }
        void Run() {
            return _handler(_data);
        }
    private:
        int  _data;
        task_handler_t _handler;
};

#define THREAD_COUNT 5
class ThreadPool
{
    public:
        ThreadPool(int thr_count = THREAD_COUNT):_max_thr(thr_count){
            pthread_mutex_init(&_mutex, NULL);
            pthread_cond_init(&_con_pool, NULL);
            for (int i = 0; i < _max_thr; i++) {
                pthread_t tid;
                //void *thread_routine(void *arg);
                int ret = pthread_create(&tid, NULL, thr_routine, (void*)this);
                if (ret != 0) {
                    std::cerr << "thread create error\n";
                    exit(0);
                }
                pthread_detach(tid);//分离线程--因为我们不关心线程的返回值
            }
        }
        ~ThreadPool(){
            pthread_mutex_destroy(&_mutex);
            pthread_cond_destroy(&_con_pool);
        }
        bool TashPush(const ThreadTask &task) {
            //外部的生产者实现任务入队
            //这里线程池任务队列并没有设置最大节点上限,因此不需要判断阻塞
            pthread_mutex_lock(&_mutex);
            _queue.push(task);
            pthread_mutex_unlock(&_mutex);
            pthread_cond_signal(&_con_pool);//入队之后唤醒一下线程池中的线程

            return true;
        }
        void QueueLock() {
            pthread_mutex_lock(&_mutex);
        }
        bool QueueIsEmpty() {
            return _queue.empty();
        }
        void ThreadWait() {
            pthread_cond_wait(&_con_pool, &_mutex);
        }
        bool TaskPop(ThreadTask *task) {
            *task = _queue.front();
            _queue.pop();
            return true;
        }
        void QueueUnlock() {
            pthread_mutex_unlock(&_mutex);
        }
    private:
        //这个函数一个类成员函数，有一个隐藏参数this指针，因此需要定义成为静态函数
        //这是一个静态函数,没有this指针，导致无法直接访问类的内部成员变量
        //通过参数传入当前的对象this指针，进而访问对象的公有成员变量以及成员函数
        static void *thr_routine(void *arg) {
            ThreadPool *pool = (ThreadPool*)arg;
            while(1) {
                //循环从队列获取任务进行处理
                pool->QueueLock();//类外无法直接访问类的私有成员，因此需要通过公有接口实现操作
                while(pool->QueueIsEmpty()) {//访问_queue是否为NULL
                    pool->ThreadWait(); //访问_con_pool以及_mutex
                }
                ThreadTask task;
                pool->TaskPop(&task); // 访问_queue
                pool->QueueUnlock();  // 访问_mutex
                //任务的处理一定要放在解锁之后完成,
                //否则，如果任务处理时间过长会导致其它线程获取不到任务
                task.Run();//通过run接口直接通过用户传入的方法完成数据处理
            }
            return NULL;
        }
    private:
        int _max_thr;//线程的数量
        std::queue<ThreadTask> _queue;//任务队列
        pthread_mutex_t _mutex; //实现队列的互斥操作
        pthread_cond_t _con_pool;//线程池中的线程等待队列
};

//这个函数就是针对一个数据要传入线程池的处理方法
void test(int data)
{
    srand(time(NULL));
    int sec = rand()%5;
    printf("thread:%p:%d sleep %d sec\n", pthread_self(), data, sec);
    sleep(sec);
}
int main()
{
    ThreadPool pool;
    for (int i = 0; i < 10; i++) {
        ThreadTask task;
        task.SetTask(i, test);// Run() {test(i)}
        pool.TashPush(task);
    }
    while(1) {
        sleep(1);
    }
    return 0;
}