基于C++11实现的任务池

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

enum  NOTIFIY_TYPE{
    ACTIVE,
    PASSIVE
};
class TypeTable
{
public:
    typedef std::mutex                   mtx_t;
    typedef std::lock_guard       locker_t;
    typedef std::unique_lock      un_lock_t;
    typedef std::condition_variable      cv_t;
    typedef std::atomic        atm_ushor_t;
    typedef std::atomic_bool             atm_bool_t;

};


class TaskPool:public TypeTable{
public:
    typedef std::function        handl_work_t;
public:
    TaskPool(TaskPool&& ref)=delete;
    TaskPool(const TaskPool& oth) = delete;
    TaskPool& operator=(const TaskPool& oth) = delete;
    TaskPool& operator=(TaskPool&& oth) = delete;


    TaskPool(int pool_thread = 1, NOTIFIY_TYPE type = NOTIFIY_TYPE::PASSIVE) :pool_thread_cnt_(pool_thread), type_notify_(type)
    {
      _init(pool_thread,type);
    }

    ~TaskPool(){
        _unInit();

    }

    bool postTask(handl_work_t hand_task_work){

        locker_t lock(mtx_);
        que_task_.push_back(hand_task_work);
        if(type_notify_==NOTIFIY_TYPE::PASSIVE&& ready_){
            cv_.notify_one();
        }else if(!ready_){
			throw std::runtime_error("task pool not ready!");
            return false;
        }
        return true;
    }

    inline bool init(int thread_cnt,NOTIFIY_TYPE type) {
        _unInit();
        return _init(thread_cnt, type);
    }


    bool _init(int thread_cnt,NOTIFIY_TYPE type){
        ready_.store(false);
        exit_.store(false);
        pool_thread_cnt_.store(thread_cnt);
        pool_thread_ready_cnt_.store(0);
        for(size_t i=0;i lock(mtx_);
				task = std::move(_getTask());
				if (!task)
					continue;
			}
            if(exit_&& !task){
				_workThreadExit();
               return;
            }
			task();
        }

    }

	
    void _methPassve(){
        pool_thread_ready_cnt_.fetch_add(1);
        while(1){
			handl_work_t task;
			{
				std::unique_lock lock(mtx_);
				cv_.wait(lock);
				task = _getTask();
				if (!task)
					continue;
			}
            if(exit_&&!task){
                _workThreadExit();
                return;
            }
			task();
        }

    }

    inline void _workThreadExit() {
        pool_thread_cnt_.fetch_sub(1);
        cv_.notify_all();
	}

private:
		handl_work_t    _getTask() {
			if (!que_task_.empty()) {
				handl_work_t task_item=std::move(que_task_.front());
				que_task_.pop_front();;
				return task_item;
			}
			return handl_work_t();
		}

private:
    std::deque  que_task_;
    atm_bool_t                exit_;
    atm_bool_t                ready_;
    atm_ushor_t               pool_thread_cnt_;
    atm_ushor_t               pool_thread_ready_cnt_;
    NOTIFIY_TYPE              type_notify_;
    cv_t                      cv_;
    mtx_t                     mtx_;

};