linux编程：模拟实现一个线程池

linux编程：模拟实现一个线程池

实现一个线程池需要构建三个类：

1. 线程任务类给定两个接口，SetTask()负责把给的数据和方法传进任务系统，Start()负责将给定数据用给定方法来处理。
2. 安全队列类，负责给线程池提供一个能够互斥访问的安全队列。
3. 线程池类提供三个接口，ThreadPool()创建指定数量的线程，TaskPush()将任务放入安全队列,*thread_entry()负责让线程取任务并进行处理。

#include<cstdio>
#include<queue>
#include<cstdlib>
#include<pthread.h>
#include<unistd.h>

#define MAX_THREAD 5
#define MAX_QUEUE 10

typedef void (*handler_t)(int data);
class ThreadTask{
    private:
        int _data;//给定的数据
        handler_t _handler;//给定的方法
    public: 
        void SetTask(int data,handler_t handler){
        _handler=handler;
        _data=data;
        }       
        void Start(){
            return _handler(_data);
        }//线程调用Start接口实现通过给定方法处理给定数据
};

class BlockQueue{
    std::queue<ThreadTask> _queue; 
    int _capacity;
    pthread_mutex_t _mutex; 
    pthread_cond_t _cond_pro;
    pthread_cond_t _cond_cus;

    public: 
        BlockQueue(int cap=MAX_QUEUE):_capacity(cap){
        pthread_mutex_init(&_mutex,NULL);
        pthread_cond_init(&_cond_pro,NULL);
        pthread_cond_init(&_cond_cus,NULL);
        }       
    ~BlockQueue(){
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond_pro);
        pthread_cond_destroy(&_cond_cus);
        }
    bool Push(ThreadTask data){
        pthread_mutex_lock(&_mutex);
        while(_queue.size()==_capacity){
        pthread_cond_wait(&_cond_pro,&_mutex);
        }
        _queue.push(data);
        pthread_mutex_unlock(&_mutex);
        pthread_cond_signal(&_cond_cus);
        return true;
        }
    bool Pop(ThreadTask *data){
        pthread_mutex_lock(&_mutex);
        while(_queue.empty()){
        pthread_cond_wait(&_cond_cus,&_mutex);
        }
        *data=_queue.front();
        _queue.pop();
        pthread_mutex_unlock(&_mutex);
        pthread_cond_signal(&_cond_pro);
        return true;
        }
};

class ThreadPool{
    private:
        int _max_thread;
        BlockQueue _queue;
    public:
        ThreadPool(int max_thr=MAX_THREAD,int max_queue=MAX_QUEUE):_queue(max_queue){
            int ret;
            pthread_t tid;
            for(int i=0;i<MAX_THREAD;i++){
                ret=pthread_create(&tid,NULL,thread_entry,(void*)this);
                if (ret!=0){
                printf("Create Thread Error!");
                exit(0);
                }
                pthread_detach(tid);
            }
        }
        bool TaskPush(ThreadTask &task){
            _queue.Push(task);
            return true;
        };
        static void *thread_entry(void *arg){
            ThreadPool *pool=(ThreadPool*)arg;
            while(1){
            ThreadTask task;
            pool->_queue.Pop(&task);//线程安全的任务出队
            task.Start();//处理任务
            }
            return NULL;
        }//线程入口函数，这个接口中完成任务处理的过程
};

void method(int data){
    printf("%p - get data:%d\n",pthread_self(),data);//打印线程id和处理的数据
    sleep(1);
}

int main(){
    ThreadPool pool;
    for(int i=0;i<10;i++){
        ThreadTask task;
        task.SetTask(i,method);
        pool.TaskPush(task);
    }
    while(1)
        sleep(1);
    return 0;
}

运行结果