Boost库实现线程池学习及线程实现的异步调用

A.Boost线程池实现

参考自： Boost库实现线程池实例

原理：使用boost的thread_group存储多个线程，使用bind方法将要处理的函数转换成线程可调用的函数进行执行；使用队列存储待处理任务，利用Mutex实现队列线程安全。

#ifndef MYTHREADPOOL_H
#define MYTHREADPOOL_H

#include 
#include 
#include 
#include 
#include 
#include 
using namespace boost;

typedef boost::function MyTask;
//任务队列--noncopyable
class MyTaskQueue : boost::noncopyable
{
private:
    std::queue m_taskQueue;
    boost::mutex m_mutex;//互斥锁
    boost::condition_variable_any m_cond;//条件变量
public:
    void push_Task(const MyTask& task){
        //加上互斥锁
        boost::unique_lock lock(m_mutex);
        m_taskQueue.push(task);
        //通知其他线程启动
        m_cond.notify_one();
    }

    MyTask pop_Task(){
        //加上互斥锁
        boost::unique_lock lock(m_mutex);
        if(m_taskQueue.empty())
        {
            //如果队列中没有任务，则等待互斥锁 
            m_cond.wait(lock);//
        }
        //指向队列首部
        MyTask task(m_taskQueue.front());
        //出队列  
        m_taskQueue.pop();
        return task;
    }
    int get_size()
    {
        return m_taskQueue.size();
    }
};

class MyThreadPool : boost::noncopyable
{
private:
    //任务队列
    MyTaskQueue m_taskQueue;
    //线程组 
    boost::thread_group m_threadGroup;
    int m_threadNum;
    /*
    volatile 被设计用来修饰被不同线程访问和修改的变量。
    volatile 告诉编译器i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，
    因而编译器生成的可执行码会重新从i的地址读取数据放在k中。 
    volatile可以保证对特殊地址的稳定访问，不会出错。
    */
    volatile bool is_run;
    void run(){//线程池中线程的处理函数
        while(is_run){
            //一直处理线程池的任务
            MyTask task = m_taskQueue.pop_Task();
            task();//运行bind的函数
        }
    }
public:
    MyThreadPool(int num):m_threadNum(num),is_run(false)//初始化列表
    {

    }
    ~MyThreadPool(){
        stop();
    }
    void init()
    {
        if(m_threadNum