C++版简单线程池

需求

之前写过一个C#版本的简单线程池http://blog.csdn.net/ylbs110/article/details/51224979

由于刚刚学习了C++11新特性中的future，于是想到用它来实现一个线程池。

实现

思路基本和C#版本的一样，主要区别是委托的实现，线程句柄的不同和线程锁：

• 本来C++有function模板，但是实现起来比较麻烦，这里主要是实现线程池，所以动态参数的委托就不实现了，直接使用typedef

  void(*Func)();来实现一个无参数无返回值的函数指针

• 线程句柄使用future
• 线程锁使用mutex

关于future和mutex的用法在C++标准库第2版里面讲的很清楚，这里不细说。

与C#版本的实现方式类似，首先实现一个线程句柄类，该类主要用来存储线程池中运行的方法的句柄，并且实现对该方法的关闭操作，完成状态查询，循环状态查询等一系列功能。

线程池中使用队列来存储还未运行的方法，所有线程也使用一个队列存储起来。所有线程都运行一个run方法，该方法主要用来从线程句柄队列中提取任务然后运行。而提取任务的方法中需要使用mutex线程锁来防止多个线程提取任务时的冲突。

原理很简单，上代码吧：

PublicData

公共数据文件，本程序集中仅仅实现了一个Func指针

#include "stdafx.h"
typedef void(*Func)();

Thread

Thread.h

#include "stdafx.h"
#include <future>
#include <chrono>
#include "PublicData.h"

using namespace std;

class Thread
{
public:
    Thread(Func f = nullptr, int waitTime = 0, int cycleTime = -1);
    void setFunc(Func f, int waitTime = 0, int cycleTime = -1);
    Func getFunc();
    bool cancel();
    bool isCancel();
    bool isDone();
    void run();
private:
    int waitTime;
    int cycleTime;
    bool isCycle = false;;
    bool isRunning = false;
    bool iscancel = false;
    bool isdone = false;
    Func _func;
};

Thread.cpp

#include "stdafx.h"
#include "Thread.h"

Thread::Thread(Func f, int waitTime, int cycleTime) :_func(f), waitTime(waitTime), cycleTime(cycleTime){
    if (waitTime < 0)
        waitTime = 0;
    if (cycleTime <= 0)
        isCycle = false;
}
void Thread::setFunc(Func f, int waitTime, int cycleTime){
    _func = f;
    this->waitTime = waitTime;
    this->cycleTime = cycleTime;
};
Func Thread::getFunc(){
    return _func;
};
bool Thread::cancel(){
    if (isdone)
        return false;
    else if (iscancel)
        return false;
    else if (isRunning && !iscancel)
        return false;
    else
        return iscancel = true;
}
bool Thread::isCancel(){
    return iscancel;
}
bool Thread::isDone(){
    return isdone;
}
void Thread::run(){
    if (isdone)
        return;
    if (_func == nullptr)
        return;
    this_thread::sleep_for(chrono::milliseconds(waitTime));
    if (iscancel)
        return;
    isRunning = true;
    if (isCycle){
        (*_func)();
        this_thread::sleep_for(chrono::milliseconds(cycleTime));
    }
    else
        (*_func)();
    isdone = true;
}

ThreadPool

ThreadPool.h

#pragma once
#include "stdafx.h"
#include <deque>
#include <chrono>
#include <future>
#include <mutex>
#include <exception>
#include "PublicData.h"
#include "Thread.h"

using namespace std;

class ThreadPool
{
public:
    ThreadPool(int i = 1);
    ~ThreadPool();
    Thread create(Func f, int waitTime = -1, int cycleTime = -1);
    void shoutdown();
    bool isShoutdown();

private:
    deque<Thread> threadDeque;
    deque<future<void>> futureDeque;
    mutex runMutex;
    int futureNum;
    Func getFunc();
    void run();
};

ThreadPool.cpp

#include "stdafx.h"
#include "ThreadPool.h"

ThreadPool::ThreadPool(int i){
    threadDeque = deque<Thread>();
    futureDeque = deque<future<void>>();
    futureNum = i;
    while (i-- > 0)
    {
        futureDeque.push_back(async(launch::async, [this]{
            //run();
            while (true)
            {
                if (threadDeque.size() > 0){
                    auto r = threadDeque.begin()->getFunc();
                    threadDeque.pop_front();
                    r();
                }
            }
        }));
    }
};

ThreadPool::~ThreadPool(){};

Thread ThreadPool::create(Func f, int waitTime, int cycleTime){
    threadDeque.push_back(Thread(f, waitTime, cycleTime));
    return threadDeque.back();
};

void ThreadPool::shoutdown(){
    while (futureDeque.size()>0)
    {
        futureDeque.begin()->~future();
        futureDeque.pop_front();
    }
    while (threadDeque.size()>0)
    {
        threadDeque.begin()->cancel();
        threadDeque.pop_front();
    }
};

bool ThreadPool::isShoutdown(){
    return !(futureDeque.size() > 0);
};
Func ThreadPool::getFunc(){
    lock_guard<mutex> l(runMutex);
    auto r = threadDeque.begin()->getFunc();
    threadDeque.pop_front();
    return r;
};
void ThreadPool::run(){
    while (true)
    {
        if (threadDeque.size() > 0){
            auto r = threadDeque.begin()->getFunc();
            threadDeque.pop_front();
            r();
        }
    }
};

转载请注明出处：http://blog.csdn.net/ylbs110/article/details/51337530

测试

测试方法

void showA(){
    for (int i = 0; i < 500; i++)
        printf("a");
    printf("\n");
}
void showB(){
    for (int i = 0; i < 500; i++)
        printf("b");
    printf("\n");
}
void showC(){
    for (int i = 0; i < 500; i++)
        printf("c");
    printf("\n");
}
void showD(){
    for (int i = 0; i < 500; i++)
        printf("d");
    printf("\n");
}

调用

    ThreadPool t=ThreadPool(5);
    Thread a = t.create(showA);
    Thread b = t.create(showB);
    Thread c = t.create(showC);
    Thread d = t.create(showD);
    system("pause");
    return 0;

运行结果

aaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacccccccccccccccccccccccccccccccccccccccccccccccccbbbbbbbbbbbbbbbbb请 按任意键继续. . . bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcccccccccccccccbbbbbbbbbbbbbbbbbbbbbbbbddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
cbbccccbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

从结果可以看出，四个线程执行输出的时候没有先后顺序，运行成功。