简单线程池

thread_pool.h

#ifndef __THREAD_POOL_H
#define __THREAD_POOL_H

#include <vector>
#include <string>
#include <pthread.h>

using namespace std;
//执行任务的类:设置任务数据并执行
class CTask
{
protected:
    string m_strTaskName; //任务名称
    void *m_ptrData;      //要执行的任务的具体数据
public:
    CTask() = default;
    CTask(string &taskName)
        : m_strTaskName(taskName), m_ptrData(NULL) {}
    virtual int Run() = 0;
    void setData(void *data); // 设置任务数据
    virtual ~CTask() {}
};

//线程池管理类
class CThreadPool
{
private:
    static vector<CTask *> m_vecTaskList; //任务列表
    static bool shutdown;                 // 线程退出标志
    int m_iThreadNum;                     //线程池中启动的线程数
    pthread_t *pthread_id;

    static pthread_mutex_t m_pthreadMutex; // 线程同步锁
    static pthread_cond_t m_pthreadCond;   //线程同步条件变量
protected:
    static void *ThreadFunc(void *threadData); //新线程的线程回调函数
    static int MoveToIdle(pthread_t tid);      // 线程执行结束后,把自己放入空闲线程中
    static int MoveToBusy(pthread_t tid);      //移入到忙碌线程中
    int Create();                              //创建线程池中的线程
public:
    CThreadPool(int threadNum);
    int AddTask(CTask *task); // 把任务添加到任务队列中
    int StopAll();            //使线程池中的所有线程退出
    int getTaskSize();        //获取当前任务队列中的任务数
};
#endif

thread_pool.cpp

#include "thread_pool.h"
#include <cstdio>

void CTask::setData(void *data)
{
    m_ptrData = data;
}
//静态成员初始化
vector<CTask *> CThreadPool::m_vecTaskList;
bool CThreadPool::shutdown = false;
pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;

//线程管理类构造函数
CThreadPool::CThreadPool(int threadNum)
{
    this->m_iThreadNum = threadNum;
    printf("I will create %d threads.\n", threadNum);
    Create();
}

//线程回调函数
void *CThreadPool::ThreadFunc(void *threadData)
{
    pthread_t tid = pthread_self();
    while (1)
    {
        pthread_mutex_lock(&m_pthreadMutex);
        //如果队列为空,等待新任务进入任务队列
        while (m_vecTaskList.size() == 0 && !shutdown)
        {
            pthread_cond_wait(&m_pthreadCond, &m_pthreadMutex);
        }
        //关闭线程
        if (shutdown)
        {
            pthread_mutex_unlock(&m_pthreadMutex);
            printf("[tid: %lu]\texit\n", pthread_self());
            pthread_exit(NULL);
        }

        printf("[tid: %lu]\trun: ", tid);
        vector<CTask *>::iterator iter = m_vecTaskList.begin();
        //取出一个任务并处理
        CTask *task;
        if (iter != m_vecTaskList.end())
        {
            task = *iter;
            m_vecTaskList.erase(iter);
        }
        pthread_mutex_unlock(&m_pthreadMutex);

        task->Run(); //执行任务
        printf("[tid: %lu]\tidle\n", tid);
    }
    return (void *)0;
}
//往任务队列里添加任务并发出线程同步信号
int CThreadPool::AddTask(CTask *task)
{
    pthread_mutex_lock(&m_pthreadMutex);
    m_vecTaskList.push_back(task);
    pthread_mutex_unlock(&m_pthreadMutex);
    pthread_cond_signal(&m_pthreadCond);

    return 0;
}

//创建线程
int CThreadPool::Create()
{
    pthread_id = new pthread_t[m_iThreadNum];
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_create(&pthread_id[i], NULL, ThreadFunc, NULL);
    }
    return 0;
}

//停止所有线程
int CThreadPool::StopAll()
{
    //避免重复调用
    if (shutdown)
    {
        return -1;
    }
    printf("Now I will end all threads!\n\n");

    //唤醒所有等待进程,线程池也要销毁了

    shutdown = true;
    pthread_cond_broadcast(&m_pthreadCond);

    //清理僵尸进程
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_join(pthread_id[i], NULL);
    }
    delete[] pthread_id;
    pthread_id = NULL;

    //销毁互斥锁和条件变量
    pthread_mutex_destroy(&m_pthreadMutex);
    pthread_cond_destroy(&m_pthreadCond);

    return 0;
}
//获取当前队列中的任务数
int CThreadPool::getTaskSize()
{
    return m_vecTaskList.size();
}