Linux C++线程池

1、为什么需要线程池？

部分应用程序需要执行很多细小的任务，对于每个任务都创建一个线程来完成，任务完成后销毁线程，而这就会产生一个问题：当执行的任务所需要的时间T1小于等于创建线程时间T2和销毁线程时间T3总和时即T1 <= T2 + T3，应用处理任务的响应能力会大大减弱，从而影响了应用程序性能，为了解决这类问题，线程池技术提供了很好的解决方案。线程池顾名思义就是把线程资源池化，在应用启动时一次性创建合适数量的线程，当需要执行任务时就从线程池中分配一个已经创建好的线程来执行，执行完在把线程归还，只在应用停时再一次性销毁所有的线程。

2、线程池的基本组成部分

一个简单的线程池至少包括下列的组成部分：

1）线程池管理器（ThreadPool）:用于创建一个线程池对象并管理线程池，如分配任务给某个空闲线程，查看当前线程状态等等的操作。

2）工作线程（WorkThread）:线程池中线程，可能是挂起，可能是被分配了任务，若然是挂起，则用一个信号量去阻塞直到有任务分配。

3）任务接口（Task）:每个任务必须实行的接口，以供工作线程调度任务执行。

3、Unix下的线程池实现

将给大家展示的线程池实现的类如下,含有比较多的面向对象设计思想。
主要是

一个线程池管理多个工作线程类,每个工作线程类对象管理一个线程。

1）Mutex:互斥量类，里面只有一个pthread_mutex_t的私有成员，对POSIX互斥量进行封装，后面用于线程池的队列和栈。

Mutex.h

#ifndef MUTEX_H
#define MUTEX_H

#include <iostream>
#include <pthread.h>
using namespace std;

class Mutex
{
public:
    Mutex();
    void Lock();
    void Unlock();

private:
    pthread_mutex_t mutex;
};

#endif

Mutex.cpp

#include "Mutex.h"

Mutex::Mutex()
{
    pthread_mutex_init(&mutex,NULL);
}

void Mutex::Lock()
{
    pthread_mutex_lock(&mutex);
}

void Mutex::Unlock()
{
    pthread_mutex_unlock(&mutex);
}

2）BaseTask:任务的抽象基类，任何具体的任务都要继承该类，并实现自己的void * run()函数，
即线程运行的函数。在这里继承的类定义实现在main函数里面。抽象类不能被实例化，但可以声明为指针指向继承的子类。

BaseTask.h

#ifndef BASE_TASK_H
#define BASE_TASK_H

#include <iostream>
using namespace std;

class BaseTask
{
    public:
        virtual void run() = 0;
};

#endif

3).MyTask:具体任务类，继承了BaseTask，实现了具体任务。

MyTask.h

#ifndef MYTASK_H
#define MYTASK_H
#include "BaseTask.h"

class MyTask : public BaseTask
{
public:
    virtual void run(void);
};

#endif

MyTask.cpp

 #include "MyTask.h"
 
 void MyTask::run(void)
 {
     cout<<"Hello MyTask"<<endl;
 }

4).MyThread: 对POSIX线程的C++封装，实现了执行任务的基本接口

MyThread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <iostream>
#include <pthread.h>
#include <semaphore.h>
#include "BaseTask.h"


// 前置定义
class MyThreadPool;

class MyThread
{
public:
    MyThread(MyThreadPool* mtp);
    void Set_Task(BaseTask* task);
    void Start_Task();
    /* 线程启动函数 必须写成静态成员函数 传入的参数为类对象自己*/
    static void* Start_Func(void* arg);
    /* 完成一个任务后 询问线程池管理器是否有未完成的任务*/
    bool Fetch_Task();
    /* 无更多任务 让自己进入线程池栈*/
    void Recycle();
private:
    /* 用于挂起线程 */
    sem_t sem;
    pthread_t tid;
    BaseTask* task;
    MyThreadPool* mtp;
};

#endif

MyThread.cpp

#include "MyThreadPool.h"
#include "MyThread.h"


MyThread::MyThread(MyThreadPool* mtp)
{
    sem_init(&sem,0,0);
    this->mtp = mtp;
    pthread_create(&tid,NULL,Start_Func,(void*)this);
}

void MyThread::Set_Task(BaseTask* task)
{
    this->task = task;
}

void MyThread::Start_Task()
{
    sem_post(&sem);
}

void* MyThread::Start_Func(void* arg)
{
    MyThread* mt = (MyThread*) arg;
    while(1)
    {
        sem_wait(&mt->sem);
        mt->task->run();
        if(mt->Fetch_Task())
            mt->Start_Task();
        else
            mt->Recycle();
    }
}

bool MyThread::Fetch_Task()
{
    return mtp->FetchTask(this);
}

void MyThread::Recycle()
{
    mtp->Recycle(this);
}

MyThreadPool:线程池管理类，实现线程的创建管理和任务调度。

MyThreadPool.h

#ifndef MYTHREADPOOL_H
#define MYTHREADPOOL_H

#include <iostream>
#include <stack>
#include <queue>
#include "Mutex.h"
#include "BaseTask.h"

class MyThread;

class MyThreadPool
{
public:
    /* no为要开辟的线程数目*/
    MyThreadPool(int no);
    /* 添加任务*/
    void AddTask(BaseTask* task);
    /* 供线程类调用 让线程类对象询问线程池任务队列中是否仍有任务未完成*/
    bool FetchTask(MyThread* mt);
    /* 回收线程 */
    void Recycle(MyThread* mt);
private:
    int no;
    Mutex smutex;
    Mutex qmutex;

    stack<MyThread*> sthread;
    queue<BaseTask*> qtask;
};

#endif

MyThreadPool.cpp

#include "MyThreadPool.h"
#include "MyThread.h"

MyThreadPool::MyThreadPool(int no)
{
    this->no = no;

    for(int i=0;i<no;++i)
    {
        sthread.push(new MyThread(this));
    }
}

void MyThreadPool::AddTask(BaseTask* task)
{
    smutex.Lock();
    if (!sthread.empty())
    {
        MyThread* mt = sthread.top();
        sthread.pop();
        smutex.Unlock();
        mt->Set_Task(task);
        mt->Start_Task();
    }
    else
    {
        smutex.Unlock();    
        qmutex.Lock();
        qtask.push(task);
        qmutex.Unlock();
    }
}

bool MyThreadPool::FetchTask(MyThread* mt)
{
    qmutex.Lock();
    if (!qtask.empty())
    {
        mt->Set_Task(qtask.front());
        qmutex.Unlock();
        return true;
    }
    else
    {
        qmutex.Unlock();
        return false;
    }
}

void MyThreadPool::Recycle(MyThread* mt)
{
    smutex.Lock();
    sthread.push(mt);
    smutex.Unlock();
}

main.cpp

#include "MyThread.h"
#include "MyThreadPool.h"
#include "Mutex.h"
#include "MyTask.h"

int main()
{
    MyThreadPool mtp(3);
    while(1)
    {
        BaseTask* task = new MyTask;
        mtp.AddTask(task);
        sleep(5);
        delete task;
        task = NULL;
    }
}

makefile

pro: main.cpp libtp.a MyTask.cpp
    g++ -lpthread  main.cpp -L. -ltp MyTask.cpp -o pro

libtp.a: MyThreadPool.o MyThread.o Mutex.o
    ar cr libtp.a Mutex.o MyThreadPool.o MyThread.o

MyThread.o:MyThread.cpp
    g++ -c -lpthread MyThread.cpp -o MyThread.o

MyThreadPool.o:MyThreadPool.cpp
    g++ -c -lpthread MyThreadPool.cpp -o MyThreadPool.o

Mutex.o:Mutex.cpp
    g++ -c -lpthread Mutex.cpp -o Mutex.o

clean:
    rm libtp.a MyThreadPool.o Mutex.o MyThread.o pro

执行 make 成功后，执行./pro 即可

编译: 我首先将线程类(MyThread.o) 互斥类(Mutex.o) 和 线程池类(MyThreadPool.o) 打包成一个静态库

静态库留出两个接口 一个是线程池的初始化 另外一个是用户自己继承BaseTask的run函数后 调用线程池的类对象 AddTask接口去增加任务

所以使用者只需自己指定要开辟的线程数(线程池的构造函数) 和 自定义 任务类对象即可使用这个线程池.

ps:所有文件都放在同一个目录下