c/c++ 线程池

概念

• 原理

  线程池简单来说就是有一堆已经创建好的线程（最大数目一定），初始时他们都处于空闲状态，当有新的任务进来，从线程池中取出一个空闲的线程处理任务，然后当任务处理完成之后，该线程被重新放回到线程池中，供其他的任务使用，当线程池中的线程都在处理任务时，就没有空闲线程供使用，此时，若有新的任务产生，只能等待线程池中有线程结束任务空闲才能执行

• 为什么使用线程池

  因为线程的创建、和清理都是需要耗费系统资源的。假设某个线程的创建、运行和销毁的时间分别为T1、T2、T3，当T1+T3的时间相对于T2不可忽略时，线程池的就有必要引入了，尤其是处理数百万级的高并发处理时。

  线程池提升了多线程程序的性能，因为线程池里面的线程都是现成的而且能够重复使用，我们不需要临时创建大量线程，然后在任务结束时又销毁大量线程。一个理想的线程池能够合理地动态调节池内线程数量，既不会因为线程过少而导致大量任务堆积，也不会因为线程过多了而增加额外的系统开销。

• 优点

  第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
  第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。

• 生产者与消费者模型

  线程池的原理是一个非常典型的生产者消费者同步问题。线程池至少有两个主要动作，一个是主程序不定时地向线程池添加任务，另一个是线程池里的线程领取任务去执行。

  主程序执行入队操作，把任务添加到一个队列里面；池子里的多个工作线程共同对这个队列试图执行出队操作，这里要保证同一时刻只有一个线程出队成功，抢夺到这个任务，其他线程继续共同试图出队抢夺下一个任务。所以在实现线程池之前，我们需要一个队列。

  这里的生产者就是主程序，生产任务（增加任务），消费者就是工作线程，消费任务（执行、减少任务）。因为这里涉及到多个线程同时访问一个队列的问题，所以我们需要互斥锁来保护队列，同时还需要条件变量来处理主线程通知任务到达、工作线程抢夺任务的问题。

c 实现线程池

//condition.h
#ifndef _CONDITION_H_
#define _CONDITION_H_

#include 

//封装一个互斥量和条件变量作为状态
typedef struct condition
{
    pthread_mutex_t pmutex;
    pthread_cond_t pcond;
}condition_t;

//对状态的操作函数
int condition_init(condition_t *cond);
int condition_lock(condition_t *cond);
int condition_unlock(condition_t *cond);
int condition_wait(condition_t *cond);
int condition_timedwait(condition_t *cond, const struct timespec *abstime);
int condition_signal(condition_t* cond);
int condition_broadcast(condition_t *cond);
int condition_destroy(condition_t *cond);

#endif

//condition.c
#include "condition.h"

//初始化
int condition_init(condition_t *cond)
{
    int status;
    if((status = pthread_mutex_init(&cond->pmutex, NULL)))
        return status;

    if((status = pthread_cond_init(&cond->pcond, NULL)))
        return status;

    return 0;
}

//加锁
int condition_lock(condition_t *cond)
{
    return pthread_mutex_lock(&cond->pmutex);
}

//解锁
int condition_unlock(condition_t *cond)
{
    return pthread_mutex_unlock(&cond->pmutex);
}

//等待
int condition_wait(condition_t *cond)
{
    return pthread_cond_wait(&cond->pcond, &cond->pmutex);
}

//固定时间等待
int condition_timedwait(condition_t *cond, const struct timespec *abstime)
{
    return pthread_cond_timedwait(&cond->pcond, &cond->pmutex, abstime);
}

//唤醒一个睡眠线程
int condition_signal(condition_t* cond)
{
    return pthread_cond_signal(&cond->pcond);
}

//唤醒所有睡眠线程
int condition_broadcast(condition_t *cond)
{
    return pthread_cond_broadcast(&cond->pcond);
}

//释放
int condition_destroy(condition_t *cond)
{
    int status;
    if((status = pthread_mutex_destroy(&cond->pmutex)))
        return status;

    if((status = pthread_cond_destroy(&cond->pcond)))
        return status;

    return 0;
}

//threadpool.h
#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

//线程池头文件

#include "condition.h"

//封装线程池中的对象需要执行的任务对象
typedef struct task
{
    void *(*run)(void *args);  //函数指针，需要执行的任务
    void *arg;              //参数
    struct task *next;      //任务队列中下一个任务
}task_t;


//下面是线程池结构体
typedef struct threadpool
{
    condition_t ready;    //状态量
    task_t *first;       //任务队列中第一个任务
    task_t *last;        //任务队列中最后一个任务
    int counter;         //线程池中已有线程数
    int idle;            //线程池中空闲线程数
    int max_threads;     //线程池最大线程数
    int quit;            //是否退出标志
}threadpool_t;


//线程池初始化
void threadpool_init(threadpool_t *pool, int threads);

//往线程池中加入任务
void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg);

//摧毁线程池
void threadpool_destroy(threadpool_t *pool);

#endif

//threadpool.c
#include "threadpool.h"
#include 
#include 
#include 
#include 
#include 

//创建的线程执行
void *thread_routine(void *arg)
{
    struct timespec abstime;
    int timeout;
    printf("thread %d is starting\n", (int)pthread_self());
    threadpool_t *pool = (threadpool_t *)arg;
    while(1)
    {
        timeout = 0;
        //访问线程池之前需要加锁
        condition_lock(&pool->ready);
        //空闲
        pool->idle++;
        //等待队列有任务到来 或者 收到线程池销毁通知
        while(pool->first == NULL && !pool->quit)
        {
            //否则线程阻塞等待
            printf("thread %d is waiting\n", (int)pthread_self());
            //获取从当前时间，并加上等待时间， 设置进程的超时睡眠时间
            clock_gettime(CLOCK_REALTIME, &abstime);
            abstime.tv_sec += 2;
            int status;
            status = condition_timedwait(&pool->ready, &abstime);  //该函数会解锁，允许其他线程访问，当被唤醒时，加锁
            if(status == ETIMEDOUT)
            {
                printf("thread %d wait timed out\n", (int)pthread_self());
                timeout = 1;
                break;
            }
        }

        pool->idle--;
        if(pool->first != NULL)
        {
            //取出等待队列最前的任务，移除任务，并执行任务
            task_t *t = pool->first;
            pool->first = t->next;
            //由于任务执行需要消耗时间，先解锁让其他线程访问线程池
            condition_unlock(&pool->ready);
            //执行任务
            t->run(t->arg);
            //执行完任务释放内存
            free(t);
            //重新加锁
            condition_lock(&pool->ready);
        }

        //退出线程池
        if(pool->quit && pool->first == NULL)
        {
            pool->counter--;//当前工作的线程数-1
            //若线程池中没有线程，通知等待线程（主线程）全部任务已经完成
            if(pool->counter == 0)
            {
                condition_signal(&pool->ready);
            }
            condition_unlock(&pool->ready);
            break;
        }
        //超时，跳出销毁线程
        if(timeout == 1)
        {
            pool->counter--;//当前工作的线程数-1
            condition_unlock(&pool->ready);
            break;
        }

        condition_unlock(&pool->ready);
    }

    printf("thread %d is exiting\n", (int)pthread_self());
    return NULL;

}


//线程池初始化
void threadpool_init(threadpool_t *pool, int threads)
{

    condition_init(&pool->ready);
    pool->first = NULL;
    pool->last =NULL;
    pool->counter =0;
    pool->idle =0;
    pool->max_threads = threads;
    pool->quit =0;

}


//增加一个任务到线程池
void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg)
{
    //产生一个新的任务
    task_t *newtask = (task_t *)malloc(sizeof(task_t));
    newtask->run = run;
    newtask->arg = arg;
    newtask->next=NULL;//新加的任务放在队列尾端

    //线程池的状态被多个线程共享，操作前需要加锁
    condition_lock(&pool->ready);

    if(pool->first == NULL)//第一个任务加入
    {
        pool->first = newtask;
    }
    else
    {
        pool->last->next = newtask;
    }
    pool->last = newtask;  //队列尾指向新加入的线程

    //线程池中有线程空闲，唤醒
    if(pool->idle > 0)
    {
        condition_signal(&pool->ready);
    }
    //当前线程池中线程个数没有达到设定的最大值，创建一个新的线程
    else if(pool->counter < pool->max_threads)
    {
        pthread_t tid;
        pthread_create(&tid, NULL, thread_routine, pool);
        pool->counter++;
    }
    //结束，访问
    condition_unlock(&pool->ready);
}

//线程池销毁
void threadpool_destroy(threadpool_t *pool)
{
    //如果已经调用销毁，直接返回
    if(pool->quit)
    {
    return;
    }
    //加锁
    condition_lock(&pool->ready);
    //设置销毁标记为1
    pool->quit = 1;
    //线程池中线程个数大于0
    if(pool->counter > 0)
    {
        //对于等待的线程，发送信号唤醒
        if(pool->idle > 0)
        {
            condition_broadcast(&pool->ready);
        }
        //正在执行任务的线程，等待他们结束任务
        while(pool->counter)
        {
            condition_wait(&pool->ready);
        }
    }
    condition_unlock(&pool->ready);
    condition_destroy(&pool->ready);
}

//main.c
#include "threadpool.h"
#include 
#include 
#include 

void* mytask(void *arg)
{
    printf("thread %d is working on task %d\n", (int)pthread_self(), *(int*)arg);
    sleep(1);
    free(arg);
    return NULL;
}

//测试代码
int main(void)
{
    threadpool_t pool;

    //初始化线程池，最多三个线程
    threadpool_init(&pool, 3);
    int i;
    //创建十个任务
    for(i=0; i < 10; i++)
    {
        int *arg = (int*)malloc(sizeof(int));
        *arg = i;
        threadpool_add_task(&pool, mytask, arg);
    }
    threadpool_destroy(&pool);
    return 0;
}

注：pro文件添加LIBS += -lpthread

转载链接，附另一Github源码

c++ 实现线程池

• 一般来说实现一个线程池主要包括以下4个组成部分
  
  • 线程管理器：用于创建并管理线程池
  • 工作线程：线程池中实际执行任务的线程。在初始化线程时会预先创建好固定数目的线程在池中，这些初始化的线程一般处于空闲状态。
  • 任务接口：每个任务必须实现的接口。当线程池的任务队列中有可执行任务时，被空间的工作线程调去执行（线程的闲与忙的状态是通过互斥量实现的），把任务抽象出来形成一个接口，可以做到线程池与具体的任务无关。
  • 任务队列：用来存放没有处理的任务。提供一种缓冲机制。实现这种结构有很多方法，常用的有队列和链表结构。
  • 流程图如下：
    

//thread_pool.h
#ifndef __THREAD_POOL_H
#define __THREAD_POOL_H

#include 
#include 
#include 

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 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 

void CTask::setData(void* data)
{
    m_ptrData = data;
}

//静态成员初始化
vector 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::iterator iter = m_vecTaskList.begin();
        //取出一个任务并处理之
        CTask* task = *iter;
        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();
}

//main.cpp
#include "thread_pool.h"
#include 
#include 
#include 

class CMyTask: public CTask
{
public:
    CMyTask() = default;
    int Run()
    {
        printf("%s\n", (char*)m_ptrData);
        int x = rand()%4 + 1;
        sleep(x);
        return 0;
    }
    ~CMyTask() {}
};

int main()
{
    CMyTask taskObj;
    char szTmp[] = "hello!";
    taskObj.setData((void*)szTmp);
    CThreadPool threadpool(5);  //线程池大小为5

    for(int i = 0; i < 10; i++)
        threadpool.AddTask(&taskObj);

    while(1)
    {
        printf("There are still %d tasks need to handle\n", threadpool.getTaskSize());
        //任务队列已没有任务了
        if(threadpool.getTaskSize()==0) {
            //清除线程池
            if(threadpool.StopAll() == -1) {
                printf("Thread pool clear, exit.\n");
                exit(0);
            }
        }
        sleep(2);
        printf("2 seconds later...\n");
    }
    return 0;
}

转载链接

c++11实现线程池

注意在.pro文件中需要添加

QMAKE_CXXFLAGS += -std=c++11 -pthread
LIBS += -pthread