---

5.5线程同步机制类封装及线程池实现

线程池

线程池是由服务器预先创建的一组子线程，线程池中的线程数据应该与CPU数据差不多。线程池中的所有子线程都运行着相同的代码。当有新的任务到来时，主线程将通过某种方式选择线程池中的某一个子线程来为之服务。相比与动态的创建子线程，选择一个已经存在的子线程的代价显然要小得多。至于主线程选择哪个子线程来为新任务服务，则有多种方式：

• 主线程使用某种算法来主动选择子线程。最简单、最常用的算法是随机算法和Round Robin（轮流选取）算法，但更优秀、更智能的算法将使任务在各个工作线程中更均匀地分配，从而减轻服务器的整体压力。
• 主线程和所有子线程通过一个共享的工作队列来同步，子线程都睡眠在该工作队列上。当有新的任务到来时，主线程将任务添加到工作队列中。这将唤醒正在等待任务的子线程，不过只有一个子线程将获得新任务的接管权，它可以从工作队列中取出任务并执行之，而其他子线程将继续睡眠在工作队列上。

线程池的一般模型为：

线程池中的线程数量最直接的限制因素是中央处理器（CPU）的处理器(process/cores)的数量N；如果你的CPU是4-cores的，对于CPU密集型的任务（如视频剪辑等消耗CPU计算资源的任务）来说，那线程池中的线程数量最好也设置为4（或者+1防止其他因素造成的线程阻塞）；对于IO密集型的任务，一般要多于CPU的核数，因为线程间竞争的不是CPU的计算资源而是IO，IO的处理一般较慢，多于cores数的线程将为CPU争取更多的任务，不至在线程处理IO的过程造成CPU空闲导致资源浪费。

• 空间换时间，浪费服务器的硬件资源，换取运行效率
• 池是一组资源的集合，这组资源在服务器启动之初就完全创建好并初始化，这称为静态资源
• 当服务器进入正式运行阶段，开始处理客户请求的时候，如果它需要相关的资源，可以直接从池中获取，无需动态分配
• 当服务器处理完一个客户连接后，可以把相关的资源放回池中，无需执行系统调用释放资源

线程同步机制类封装

#ifndef LOCKER_H
#define LOCKER_H#include <exception>
#include <pthread.h>
#include <semaphore.h>//线程同步机制封装类//互斥锁类
class locker{
public:locker(){if(pthread_mutex_init(&m_mutex,NULL)!=0){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;}private:pthread_mutex_t m_mutex;
};//条件变量类
class cond{
public:cond(){if(pthread_cond_init(&m_cond,NULL)!=0){throw std::exception();}}~cond(){pthread_cond_destroy(&m_cond);}bool wait(pthread_mutex_t *m_mutex){int ret=0;//pthread_cond_wait()线程同步函数，用于等待条件变量的信号//当线程调用该函数时，它会释放锁并进入等待状态，直到另一个线程发出信号并通知该线程条件变量已经满足//此时，该线程会重新获得锁并继续执行ret=pthread_cond_wait(&m_cond,m_mutex);return ret==0;}bool timewait(pthread_mutex_t *m_mutex,struct timespec t){//struct timespec t提供秒和纳秒级的时间精度int ret=0;//指定时间内有信号传过来时，pthread_cond_timedwait()返回0，否则返回一个非0数ret=pthread_cond_timedwait(&m_cond,m_mutex,&t);return ret==0;}bool signal(){//通知其他线程某个条件已经满足的函数return pthread_cond_signal(&m_cond)==0;}bool broadcast(){//唤醒所有在条件变量上等待的线程的函数return pthread_cond_broadcast(&m_cond)==0;}
private:pthread_cond_t m_cond;
};//信号量类
class sem{
public:sem(){//sem_init()：初始化一个信号量//第二个参数0表示此信号量只能为当前进程的所有线程共享//第三个参数0表示信号量的初始值为0if(sem_init(&m_sem,0,0)!=0){throw std::exception();}}sem(int num){if(sem_init(&m_sem,0,num)!=0){throw std::exception();}}~sem(){sem_destroy(&m_sem);}//等待信号量//从信号量的值减去一个1，但它永远会先等待该信号量为一个非零值才开始做减法bool wait(){return sem_wait(&m_sem)==0;}//增加信号量//给信号量的值加上一个1，当有线程阻塞在这个信号量上时，调用这个函数会使其中一个线程不再阻塞bool post(){return sem_post(&m_sem)==0;}private:sem_t m_sem;};
#endif

线程池实现

#ifndef THREADPOOL_H
#define THREADPOOL_H#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include "locker.h"// 线程池类，将它定义为模板类是为了代码复用，模板参数T是任务类
template<typename T>
class threadpool {
public:/*thread_number是线程池中线程的数量，max_requests是请求队列中最多允许的、等待处理的请求的数量*/threadpool(int thread_number = 8, int max_requests = 10000);~threadpool();bool append(T* request);private:/*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/static void* worker(void* arg);void run();private:// 线程的数量int m_thread_number;  // 描述线程池的数组，大小为m_thread_number    pthread_t * m_threads;// 请求队列中最多允许的、等待处理的请求的数量  int m_max_requests; // 请求队列std::list< T* > m_workqueue;  // 保护请求队列的互斥锁locker m_queuelocker;   // 是否有任务需要处理sem m_queuestat;// 是否结束线程          bool m_stop;                    
};template< typename T >
threadpool< T >::threadpool(int thread_number, int max_requests) : m_thread_number(thread_number), m_max_requests(max_requests), m_stop(false), m_threads(NULL) {if((thread_number <= 0) || (max_requests <= 0) ) {throw std::exception();}m_threads = new pthread_t[m_thread_number];if(!m_threads) {throw std::exception();}// 创建thread_number 个线程，并将他们设置为脱离线程。for ( int i = 0; i < thread_number; ++i ) {printf( "create the %dth thread\n", i);if(pthread_create(m_threads + i, NULL, worker, this ) != 0) {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_requests ) {m_queuelocker.unlock();return false;}m_workqueue.push_back(request);m_queuelocker.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