线程池定义
线程池是服务器预先创建一组子线程,以空间换时间,数量应该和电脑CPU数量差不多,线程池中所有线程执行形同的代码。当有新的任务到来的时候,主线程通过某种方式唤醒线程池中的一个子线程为之服务。
主线程唤醒子线程的方式有多种,;
主线程通过某种算法选择子线程,比如随机算法或者round robin算法
主线程和子线程通过一个共享的工作队列来同步,子线程都睡眠在该工作队列中。有新的任务到来时候,主线程将任务添加到工作队列中,这将唤醒正在等待任务的子线程,每次获取任务的时候需要通过互斥锁,因此只有一个子线程将会获得新任务的接管权,它可以从工作队列中取出任务并执行,
线程池的结构
采用面向对象的方式进行编写程序,可减少代码量。
线程同步
1:多线程肯定会涉及到线程同步的问题,防止多个线程对同一个资源进行访问造成的不可预知的错误。采用锁的机制来解决这个问题。
// 互斥锁类
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;
};
:2:同时对于工作队列中有无数据,如果没有数据 应该让线程阻塞在那,如果有数据则唤醒线程池
// 条件变量类
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;
ret = pthread_cond_wait(&m_cond, m_mutex);
return ret == 0;
}
//超时时间
bool timewait(pthread_mutex_t *m_mutex, struct timespec t) {
int ret = 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;
};
3:信号量类
// 信号量类
class sem {
public:
sem() {
if( 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 );
}
// 等待信号量
bool wait() {
return sem_wait( &m_sem ) == 0;
}
// 增加信号量
bool post() {
return sem_post( &m_sem ) == 0;
}
private:
sem_t m_sem;
};
线程池
为了使线程池的任务更加通用,采用模板方式进行编写,便于代码复用。
// 线程池类,将它定义为模板类是为了代码复用,模板参数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);
//worker是线程要执行的代码,必须得是静态类型的
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();
}
}