C++实现一个简单的线程池

一、设计

线程池应该包括

• 保存线程的容器，保存任务的容器。
• 为了能保证避免线程对任务的竞态获取，需要对任务队列进行加锁。
• 为了使得工作线程感知任务的到来，需要使用条件变量来唤醒工作线程。
• 任务容器中的任务管理。
• 任务的处理API。

二、参数选择

使用数组存放线程，链表存放任务。

三、类设计

• 线程池类

template
class threadpool
{
public:
    threadpool(int thread_num,int max_request);
    ~threadpool();
    bool append(T* request);    // 在任务队列中添加任务
private:
    static void worker(void* arg);
    void run();
private:
    int m_thread_num;           // 线程池中的线程数
    int m_max_request;          // 任务队列最大保存的任务数
    pthread_t *m_threads;       // 保存线程的容器
    std::listm_queuework;   // 保存任务的链表
    sem m_sem;                  // 通知工作线程任务到来
    lock m_locker;				// 互斥访问任务队列
};

• 构造函数

template
threadpool::threadpool(int thread_num,int max_request):m_thread_num(thread_num),m_max_request(max_request)
{
    if(thread_num <=0 || max_request <= 0) throw std::exception();
    m_threads = new pthread_t[thread_num];
    if(!m_threads) throw std::exception();
    for(int i = 0;i < thread_num;++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
threadpool::~threadpool()
{
   delete[] m_trheads;
}

• 添加任务函数

template
bool threadpool::append(T* request)
{
    m_locker.lock();
    if(m_queuework.size() > m_max_request)
    {
         m_locker.unlock();
         return false;
    } 
    m_queuework.push_back(request);
    m_locker.unlock();
    m_sem.post();
    return true;
}

• 任务处理函数

template
void* threadpool::worker(void*arg)
{
    threadpool* pool = (threadpool*)arg;
    pool->run();
    return pool;
}

template
void threadpool::run()
{
    while(true)
    {
         m_sem.wait();
         m_locker.lock();
         if(m_queuework.empty())
         {
             m_locker.unlock();
             continue;
         }
         T* request = m_queuework.front();
         m_queuework.pop_front();
         m_locker.unlock();      
         request.process();      // 具体任务的处理业务
    }
}