c++线程池的实现

https://github.com/Wchenguang/ThreadPool/

github 传送门

------------------

1.使用实例

//测试job写文件
class job : public WJob{
private:
    int a;
    fstream file;
public:
    job(int aa){
        a = aa;
    }
    job() : job(-1) {};
    void run(){
        string str= to_string(a);
        cerr<<str;
        file.open(str.c_str(), std::fstream::out);
        for(int i = 0; i < 77870; ++i){
            file.write("good\n", 5);
        }
        file.close();
    }
};


int main(){

    job *jobs = new job[26];

    WThreadPool pool(17);

    pool.start();

    for(int i = 0; i < 26; ++i){
        pool.pushJob(&jobs[i]);
    }

    //任意输入字符结束
    pool.getCharToTerminate();

    delete [] jobs;
}

任何继承了WJob类并实现了其run接口的实例均可以推入线程池中

2. WJob

/*
 * 任务类 抽象类
 * 必须实现run接口
 */

#ifndef _WJOB_H
#define _WJOB_H

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

#endif

3.WThread

对WThread的封装，主要在于将之与WJob绑定以完成任务，并与线程池绑定，在任务结束后将自己放回空闲队列

每一个线程都运行run函数，用于等待任务

#ifndef _WTHREAD_H
#define _WTHREAD_H

#include <thread>
#include <iostream>
#include <string>

#include "WJob.h"

class WThreadPool;


class WThread{
public:

    //线程状态
    enum class THREAD_STATE{
        T_RUNNING,
        T_EXIT,
        T_WAITING
    };

private:
    //线程id
    size_t mId;
    //线程的函数
    WJob *mJob;
    //线程 初始即运行
    std::thread *pmThread;
    //全局锁
    std::mutex mMutex;
    //等待工作的条件变量
    std::condition_variable waitJobCond;
    //所关联的线程池
    WThreadPool &pool;
    //线程状态
    THREAD_STATE mState;

    //线程运行的函数
    void run();

public:


    WThread(WThreadPool &Wpool, size_t id);

    WThread(WThreadPool &Wpool);

    virtual ~WThread();
    //不可 赋值 复制
    WThread(const WThread &) = delete;
    WThread(const WThread &&) = delete;
    WThread &operator = (const WThread&) = delete;

    //设置工作并发布信号
    //无法分辨 job 是栈变量还是堆变量 因此不尝试释放
    //为了提高效率 也不拷贝
    bool setJob(WJob *job);

    //结束
    //是否该结束 由上层来判断
    void terminate();

    //将父线程挂起
    void join();

    bool joinable();

};

#endif

3.WThreadPool

线程池的封装，它开辟一个线程用于将任务队列中的任务分发至空闲队列中的空闲线程，每个空闲线程执行完任务后，会将自己放回空闲队列，并继续等待任务

其中的TS_Queue 与 TS_List 为线程安全STL 详见 https://github.com/Wchenguang/ThreadSafeSTL 

#ifndef _WTHREADPOOL_H
#define _WTHREADPOOL_H

#include <thread>
#include <queue>
#include <vector>

#include "WThread.h"
#include "TS_List.h"
#include "TS_Queue.h"

class WThreadPool{
public:
    enum class POOL_STATE{
        P_RUNNING,
        P_EXIT,
        P_SLEEP
    };
private:

    friend class WThread;

    //退出的标志任务
    WJob *EXITJOB = (WJob*)1;

    //初始化线程数
    static const int initThreadNum = 15;
    //线程数
    size_t curThreadNum;

    //用于 静态保存 池内线程的指针
    std::vector<WThread*> pThreadVec;
    //忙碌线程队列
    TS_List<WThread *> busyLine;
    //空闲线程队列
    TS_List<WThread *> idleLine;
    //任务队列
    TS_Queue<WJob*> jobLine;
    //线程锁
    std::mutex mMutex;
    //分派线程等待任务条件变量
    std::condition_variable DisWaitJobCond;
    //分派线程等待空线程
    std::condition_variable DisWaitThreadCond;
    //初始化运行线程池 变量
    std::condition_variable initPoolCond;
    //待处理任务数量
    size_t jobNum;
    //线程池状态
    POOL_STATE poolState;

    //用于创建线程分派任务的线程
    std::thread *dispatchThread;

    //分发线程的函数
    void run();

    //将线程压入空闲队列
    void pushToIdleLine(WThread *thread);
    //压入忙碌队列
    void pushToBusyLine(WThread *thread);
    //找到并从忙碌队列中移除
    void removeFromBusyLine(WThread *thread);

public:
    WThreadPool();

    WThreadPool(size_t threadNum);

    virtual ~WThreadPool();

    WThreadPool(const WThreadPool &) = delete;
    WThreadPool(WThreadPool &&) = delete;
    WThreadPool &operator = (const WThreadPool&) = delete;

    //开始接受任务
    void start();

    //添加job
    void pushJob(WJob *job);

    //用于父线程 输入任意字符结束
    void getCharToTerminate();



};

#endif