class task : public std::tr1::enable_shared_from_this<task>

{

public:

	task():exit_(false){}

	task( const task & ) = delete;

	~task(){}

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

	void start();

	void stop()

	{

		exit_ = true;

		sync_.notify_one();

	}

	void set_job( const std::function<void()> & job, const std::string & file, int line)

	{//提交任务

		{

			std::unique_lock<std::mutex> lock(mutex_);

			job_ = job;

			file_ = file;

			line_ = line;

		}

		sync_.notify_one();//通知主线程有任务要运行....

	}

	void print_job(){

		LOG(INFO)<<"sumbit from:"<<file_<<":"<<line_;

	}

private:

	bool exit_;

	std::mutex mutex_;

	std::condition_variable sync_;

	std::function< void()> job_;          //线程运行的任务。线程随意时刻。最多仅仅能运行一个任务。

	std::thread::id       id_;

	std::string		     file_;

	int                   line_;

};
void task::start()

{

	auto job_proxy = [this] (){

		id_ = std::this_thread::get_id();

		while( !exit_ )

		{

			std::unique_lock<std::mutex> lock(mutex_);

			if( job_ )

			{//有任务了，须要运行任务了

				try

				{

					job_(); //运行任务的代码

				}catch( std::exception & e)

				{

				}catch(...)

				{

				}

				job_ = std::function<void()>(); //释放任务绑定的资源，主要为闭包捕获的资源，特别是shared_ptr对象.

				tasks->job_completed( shared_from_this() ); //任务运行完毕。通知线程池

			}else{

			       //没有任务的时候，等待其它线程提交任务。。

				sync_.wait(lock);

			}

		}

	};

	std::thread t(job_proxy); //创建并启动与task管理的线程

	t.detach();               //分离模式，thread对象销毁了，可是其创建的线程还活着。

。。

}

class task_pool

{

public:

	task_pool(unsigned int pool_size = 128):max_size_(pool_size),stop_all_(true)

	{

	}

	~task_pool()

	{

	}

	void job_completed( const std::tr1::shared_ptr<task> & t)//回收task对象

	{

		std::lock_guard<std::mutex> lock(mutex_);

		bool need_to_notify = idle_tasks_.empty() && (!wait_for_running_jobs_.empty());

		busying_tasks_.erase(t);

		idle_tasks_.push_back(t);

		LOG(INFO)<<"after job_completed, current idle tasks size:"<< idle_tasks_.size()

			<<" busying tasks size:"<<busying_tasks_.size()

			<<" wait for running jobs size:"<<wait_for_running_jobs_.size();

		if( !busying_tasks_.empty() ){

			(*busying_tasks_.begin())->print_job();

		}

		if( need_to_notify )//任务太多了，之前空暇线程使用完了，有任务在等待运行。须要通知

		{

			sync_.notify_one();

		}

	};

	//提交任务

	void submit_job( const std::function<void()> & job, const std::string file, int line)

	{

		if( stop_all_ )

		{

			return;

		}

		std::lock_guard<std::mutex> lock(mutex_);

		bool need_notify = wait_for_running_jobs_.empty();

		wait_for_running_jobs_.push(std::make_tuple(job,file,line));

		if( need_notify )//等待运行的任务为空时。须要通知，其它情况不须要通知.

		{

			sync_.notify_one();

		}

	}

	void execute_job()

	{

		while(true)

		{

			std::unique_lock<std::mutex> lock(mutex_);

			while(!stop_all_ && wait_for_running_jobs_.empty() )

			{

				//等待其它线程提交任务

				sync_.wait(lock);

			}

			if( stop_all_ )

			{

				return;

			}

			while(!stop_all_ && idle_tasks_.empty())

			{

				//有任务要运行，可是没有空暇线程，等待其它任务运行完毕。

sync_.wait(lock);

			}

			if( stop_all_ )

			{

				return;

			}

			//有任务，也有空暇线程了

			auto t = get_task();

			auto job =wait_for_running_jobs_.front();

			wait_for_running_jobs_.pop();

			//分发任务到task 线程.

			t->set_job(std::get<0>(job), std::get<1>(job), std::get<2>(job));

		}

	}

	void stop_all()

	{

		std::lock_guard<std::mutex> lock(mutex_);

		stop_all_ = true;

		for( auto t : idle_tasks_ )

		{

			t->stop();

		}

		idle_tasks_.clear();

		for( auto t : busying_tasks_ )

		{

			t->stop();

		}

		while(!wait_for_running_jobs_.empty()){

			wait_for_running_jobs_.pop();

		}

		sync_.notify_one();

	}

	void start()

	{// 初始化启动线程池主线程

		try

		{

			std::thread t( [this]{ execute_job();});

			t.detach();

			stop_all_ = false;

			allocate_tasks();

		}catch( std::exception & e )

		{

			LOG(FATAL) << "start tasks pool ... error"<<e.what();

		}

	}

protected:

	std::tr1::shared_ptr<task> get_task()

	{

		//获取task对象

		if( ! idle_tasks_.empty() )

		{

			auto t = *idle_tasks_.begin();

			idle_tasks_.pop_front();  //从空暇队列移除

			busying_tasks_.insert(t); //增加忙队列

			return t;

		}

		return std::tr1::shared_ptr<task>();

	}

	void allocate_tasks() //初始化线程池

	{

		for( int i = 0 ; i < max_size_; i ++ )

		{

			std::tr1::shared_ptr<task> t( new task());

			try{

				t->start();

				idle_tasks_.push_back(t);

			}catch( std::exception & e)

			{	//超过进程最大线程数限制时。会跑出异常。。

。

				break;

			}

		}

	}

private :

	unsigned int                              max_size_;

	std::list  < std::tr1::shared_ptr<task> > idle_tasks_;   //空暇任务队列

	std::set  <  std::tr1::shared_ptr<task> > busying_tasks_;//正在运行任务的队列

	std::queue< std::tuple< std::function<void()> , std::string, int   >  > wait_for_running_jobs_; //等待运行的任务

	std::mutex             				    mutex_;

	std::condition_variable                 sync_;

	bool stop_all_;

};

• usage

static task_pool *  tasks = nullptr;

static std::once_flag init_flag;

static std::once_flag finit_flag;

void run_job(const std::function<void()> & job , const std::string &  file, int line )

{

	if( tasks != nullptr)

		tasks->submit_job(job, file,line);

}

void task_pool_init( unsigned max_task_size)

{

	std::call_once(init_flag,[max_task_size]{

		tasks = new task_pool(max_task_size);

		tasks->start();

	});

}

void task_pool_finit()

{

   std::call_once(finit_flag,[]{ tasks->stop_all();});

}