Linux---线程池

**线程池是一个线程的使用模式, 当线程创建过多的时候,会带来调度开销, 而当处理短时时间任务比较多的时候, 者中调度开销,可能会影响程序执行的性能, 而线程池维护着多个线程, 它等待着用户向他分配并发可执行任务,当没有任务到来的时候, 线程池中的线程不会退出,而是进行等待, 并且线程池中也包含一个任务队列, 用户只需要将处理的任务放在任务队列中, 而线程会自己去想任务队列中拿去任务进行处理 **

线程池的实现

线程池是由大量线程+任务队列来实现的

任务队列的结点中包含了两个成员变量, 一个是需要处理的任务的数据, 一个是这个任务的处理方式(任务的处理方式就是线程的执行函数), 除此之外还包含了一个Run接口, 该接口的作用就是,将该节点中的数据放入到执行函数中让其执行起来

typedef void  (*handler_t)(int)
class Queue_Node{
	public:
		Queue_Node(int data,handler_t handler)
			:_data(data)
			,_handler(handler)
		{}
		void Run(){
			return handler(_data);
		}
	private:
		int _data;
		handler_t _handler;
};

为了让我们的线程池保证执行的性能可以最大化的应用, 我们就想最好的情况就是, 当我们的队列中没有任务的时候,所有线程进行等待, 当我们的任务队列中满的时候,我们让用户的入队操作陷入等待, 这是一个典型的消费者与生产者模型, 因此线程池也必须保证线程安全

class ThreadPool{
	public:
		ThreadPool(int maxt=5,int maxq=10)
			:_thr(maxt)
			,_thr_num(maxt)
			,_capacity(maxq)
			,_thr_flag(false)
		{
			pthread_mutex_init(&_mutex);
			pthread_cond_init(&_con_cond);
			pthread_cond_init(&_pro_cond);
		}
		~ThreadPool(){
			pthread_mutex_destroy(&_mutex);
			pthread_cond_destroy(&_con_cond);
			pthread_cond_destroy(&_pro_cond);
		}
		bool PoolInit(){
			_thr_cur=0;
			for(int t=0;i<_thr_num;i++){
				_thr[i]=thread(&ThreadPool::thr_start,this);
				_thr_cur++
				_thr[i].detach();
			}
			return true;
		}
		bool PushThread(Queue_Node node){
			prhead_mutex_lock(&lock);
			while(1){
				pthread_cond_wait(&_pro_cond,&_mutex)
			};
			_queue.push(node);
			pthread_mutex_unlock(&_mutex);
			pthread_cond_signal(&_con_cond);
			return true;
		}
		bool Poolstop(){
            pthread_mutex_lock(&_mutex);
            _thr_flag=true;
            pthread_mutex_unlock(&_mutex);                                                                                                                   
            pthread_cond_broadcast(&_cond_con);
            while(_thr_cur>0){
                pthread_cond_broadcast(&_cond_con);
                usleep(1000);
            }
            return true;
        }
	private:
		 void thr_start(){
           while(1){
               pthread_mutex_lock(&_mutex);
               while(_queue.empty()){
                   if(_thr_flag==true){
                       cout<<pthread_self()<<" ---> 线程退出 "<<endl;
                       pthread_mutex_unlock(&_mutex);
                       _thr_cur--;
                       return;
                   }
                   pthread_cond_wait(&_cond_con,&_mutex);
               }
               MyTask tt=_queue.front();
               _queue.pop();
               pthread_mutex_unlock(&_mutex);
               pthread_cond_signal(&_cond_pro);
               //任务处理应该放在解锁之后,否知同一时间只有一个线程在处理任务
               tt.Run();
           }
           return ;
       }
	private:
		pthread_mutex_t _mutex;
		pthread_cond_t _con_cond;
		prhtead_cond_t _pro_cond;
		queue<Queue_Node> _queue;
		//任务队列的最大数
		int _capacity;
		vector<thread> _thr;
		//线程的最大数量
		int _thr_num;
		bool _thr_flag;
        int _thr_cur;
};