【c++11 新特性应用】利用bind实现通用的混合任务线程池

先简单认识一下std::bind，详细资料查阅相关资料，这里不啰嗦，假设你已经具备了理论知识：

auto f1 = bind(&fun_int, 3,std::placeholders::_1);

这名话的意思是给fun_int绑定2个参数，第一个是3，第二个本来的第1个参数，返回一个函数对象，这样调用f1(5) 等价于调用fun_int(3,5)

这样，bind就可以将任意函数的任意具体调用，生成一个指定的调用方式，比如无参调用，这样线程池只需要维护类型是std::function<void()>类型的对象即可。

具体实现如下，3个文件，ThreadPool.cpp  ThreadPool.h，main.cpp是测试文件。condition_variable之前没有用过，用的都是linux c标准的，这里现学现用，可能用bug，复核后再参考。

ThreadPool.h

#pragma once
#include <functional>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
using namespace std;

typedef function<void()> TaskType;
class ThreadPool
{
        mutex m_mtx;
        condition_variable m_cv;
        bool m_running = true;
        vector<thread> m_threads;
        //
        queue<TaskType> m_tasks;
        void Run(int id);
public:
        //初始化，自动启用线程
        ThreadPool(int tnum);
        //析构，终止
        ~ThreadPool();
        //添加一个任务
        bool AddTask(TaskType task);
        //终止线程池，消化完所有任务
        void Stop();
};

ThreadPool.cpp

#include <iostream>
#include "ThreadPool.h"

ThreadPool::ThreadPool(int tnum)
{
        //初始化放在线程初始化之前
        for(int i = 0; i < tnum; i++)
                m_threads.push_back(thread(&ThreadPool::Run, this, i));
}

ThreadPool::~ThreadPool()
{
        Stop();
}

void ThreadPool::Run(int id)
{
        while(true)
        {
                unique_lock<mutex> lck(m_mtx);
                while(m_tasks.empty())
                {
                        if(!m_running)
                        {
                                cout << "----thread end " << id << endl;
                                return;
                        }
                        m_cv.wait(lck);
                }
                //
                cout << "----deal task " << id << endl;
                auto t = m_tasks.front();
                m_tasks.pop();
                t();
        }
}

void ThreadPool::Stop()
{
        cout << "----Stop" << endl;
        m_running = false;
        while(!m_tasks.empty()) //消化完队列再终止
        {
                unique_lock<mutex> lck(m_mtx);
                m_cv.notify_all();
        }
        m_mtx.lock();                           //这里不可以使用unique_lock<mutex>，释放时机晚于join，形成死锁
        m_cv.notify_all();
        m_mtx.unlock();
        for(auto& item : m_threads)
                item.join();
        m_threads.clear();
}

bool ThreadPool::AddTask(TaskType task)
{
        cout << "----push taks" << endl;
        unique_lock<mutex> lck(m_mtx);
        m_tasks.push(task);
        m_cv.notify_one();
        return true;
}

main.cpp

#include <string>
#include <iostream>
#include "ThreadPool.h"
using namespace std;

class Obj
{
        int m_val;
public:
        Obj(int val) : m_val(val) {}
        void DisPlay()
        {
                cout << "DisPlay: " << m_val << endl;
        }
};

void fun_int(int a)
{
        cout << "fun int " << a << endl;
}

void fun_string(string a, int max)
{
        cout << "fun string " << a.length() << " " << max << endl;
}

int main()
{
        auto f1 = bind(&fun_int, 3);
        auto f2 = bind(&fun_int, 5);
        auto f3 = bind(&fun_string, "test", 1);
        auto f4 = bind(&Obj::DisPlay, Obj(11));
        function<void()> f5 = bind(&Obj::DisPlay, Obj(22));
        //
        ThreadPool pool(3);
        pool.AddTask(f1);
        pool.AddTask(f2);
        pool.AddTask(f3);
        pool.AddTask(f4);
        pool.AddTask(f5);
        return 0;
}