C++手写线程池(linux下)

线程池相关

手写线程池：

先写一个线程同步机制封装类locker.h

#ifndef LOCKER_H
#define LOCKER_H

#include<pthread.h>
#include<exception>
#include<semaphore.h>
//互斥锁类
class locker{
	private:
    	pthread_mutex_t m_mutex;
    public:
    	locker(){
            //创建互斥锁
            if(pthread_mutex_init(&m_mutex,NULL)){
                throw std::exception();
            }
        }
    	~locker(){
        	//销毁互斥锁
         (pthread_mutex_destroy(&m_mutex);          
		}
         bool lock(){
             return pthread_mutex_lock(&m_mutex)==0;
         }
         bool unlock(){
             return pthread_mutex_unlock(&m_mutex)==0;
         }
         pthread_mutex_t *get(){
             return &m_mutex;
         }
};

//条件变量类
class cond{
    private:
    	pthread_cond_t m_cond;
    public:
    	cond(){
            if(pthread_cond_init(&m_cond,NULL))
                throw std::exception();
        }
    	~cond{
            pthread_cond_destroy(&m_cond);
        }
    	bool wait(pthread_mutex_t *mutex){
            return pthread_cond_wait(&m_cond,mutex)==0;
        }
    	bool timedwait(pthread_mutex_t *mutex,struct timespec t){
            return pthread_cond_timedwait(&m_cond,mutex,&t)==0;
        }
    	bool signal(){
            return pthread_cond_signal(&m_cond)==0;
        }
    	bool broadcast(){
            return pthread_cond_broadcast(&m_cond)==0;
        }
};          

//信号量类
class sem{
    private:
        sem_t m_sem;
    public:
    sem(){
        if(sem_init(&m_sem,0,0)){
            throw std::exception();
        }
    }
    sem(int num){
        if(sem_init(&m_sem,0,num)){
            throw std::exception();
        }
    }
    ~sem(){
        sem_destroy(&m_sem);
    }
    //等待信号量
    bool wait(){
        return sem_wait(&m_sem)==0;
    }
    //增加信号量
    bool post(){
        return sem_post();
    }
};        
#endif

然后写线程池类

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include<list>
#include"locker.h"
#include<pthread.h>
//定义模板类为了代码复用
template<typename T>
class threadpool{
  private:
    //线程数量
    int m_thread_number;
    //线程池数组,大小m_thread_number
    pthread_t *m_threads;
    //请求队列中最多等待数量
    int m_max_requests;
    //请求队列
    std::list<T*> workqueue;
    //互斥锁
    locker m_queuelocker;
    //信号量判断是否有任务需要处理
    sem m_queuestat;
    //是否结束线程
    bool m_stop;
  private:
    static void * worker(void *arg);
    void run();
  public:
    threadpool(int thread_number=8,int max_requests=10000);
    ~threadpool();
    bool append(T*request);
};

template<typename T>
threadpool<T>::threadpool(int thread_number=8,int max_request=10000):m_thread_number(thread_number),m_max_requests(max_requests)
,m_stop(flase),m_threads(NULL){
    if(thread_number<=0||max_request<=0){
        throw std::exception();
    }
    mthreads = new pthread_t[m_thread_number];
    if(!mthread){
        throw std::exception();
    }
    
    for(int i=0;i<thread_number;++i){
        cout<<"正在创建第"<<i<<"个线程"<<endl;
        if(pthread_create(m_threads+i,NULL,worker,this));//worker必须是静态函数
        {
            delete [] m_threads;
            throw std::exception();
        }
        if(pthread_detach(m_threads[i])){
            delete [] m_threads;
            throw std::exception();
        }
    }
}
template<typename T>
~threadpool<T>::threadpool(){
    delete []m_threads;
    m_stop=true;
}

template<typename T>
bool threadpool<T>::append(T *request){
    m_queuelocker.lock();
    if(m_workqueue.size()>m_max_request){
        m_queuelocker.unlock();
        return false;
    }
    m_workqueue.push_back(request);
    m_queuelock.unlock();
    m_queuestat.post();
    return true;
}
template<typename T>
void *threadpool<T>::worker(void *arg){
    threadpool *pool = (threadpool *)arg;
    pool->run();
    return pool;
}
template<typename T>
void threadpool<T>::run(){
    while(!m_stop){
        m_queuestat.wait();//没有值就阻塞，有值就不阻塞，判断是否有任务需要处理
        m_queuelocker.lock();
        if(m_workqueue.empty()){
           m_queuelocker.unlock(); 
            continue;
        }
        T *request=m_workqueue.front();
        m_workqueue.pop_front();
        m_queuelocker.unlock();
        if(!request){
            continue;
        }
        request->process();//这是你自定义的请求中的任务
        
    }
}
#endif