高性能服务器编程半同步/半反应堆的线程池模板

线程池实现的半同步/半反应堆模型，使用工作队列实现主线程和工作线程的通信，利用加锁（互斥锁、信号量）实现同步操作，有点类似于“生产者-消费者”的通信模型。

缺点：

1、利用锁实现工作线程对工作队列的访问，锁的加入降低了系统效率；

2、必须保证所有客户请求都是无状态的，因为同一个连接上的不同请求可能会由不同线程处理；

优点：

1、主线程和工作线程间没有耦合关系，通用性强；

2、利用操作系统自带的信号量唤醒机制，工作线程基本可以实现公平调度（工作线程负载均衡），程序实现简单。

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include 
#include 
#include 
#include 
#include "locker.h"//对互斥锁、信号量的封装，代码略

template< typename T >
class threadpool//线程池类
{
public:
    threadpool( int thread_number = 8, int max_requests = 10000 );//thread_number为线程池线程数，max_requests为工作队列中最大的等待数
    ~threadpool();
    bool append( T* request );//向工作队列中添加请求，需要加锁操作

private:
    static void* worker( void* arg );//工作线程的运行函数，不断从工作队列中取出任务并执行，同样需要加锁操作
    void run();

private:
    int m_thread_number;
    int m_max_requests;
    pthread_t* m_threads;//线程池数据
    std::list< T* > m_workqueue;//工作队列，FIFO
    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();
    }

    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();//信号量+1，有1个工作线程会被唤醒
    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();//信号量-1
        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

关于线程运行函数：

在C++程序中使用pthread_create函数时，第3个参数必须指向一个静态函数，不能是一个对象的成员方法。因此在threadpool中要把线程运行函数定义为static。同时，要在一个静态函数中使用类的动态成员（成员函数和成员变量），可以将类的对象作为参数传递给该静态函数，通过引用该对象调用方法或访问变量。此处在pthread_create创建线程时传入this指针