// 提交一个任务
// 调用.get()获取返回值会等待任务执行完,获取返回值
// 有两种方法可以实现调用类成员，
// 一种是使用   bind： .commit(std::bind(&Dog::sayHello, &dog));
// 一种是用   mem_fn： .commit(std::mem_fn(&Dog::sayHello), this)
template<class F, class... Args>
auto commit(F&& f, Args&&... args) ->future<decltype(f(args...))>
{
	if (!_run) 
		throw runtime_error("commit on ThreadPool is stopped.");

	using RetType = decltype(f(args...)); // typename std::result_of<F(Args...)>::type, 函数 f 的返回值类型
	auto task = make_shared<packaged_task<RetType()>>(
		bind(forward<F>(f), forward<Args>(args)...)
	); // 把函数入口及参数,打包(绑定)
	future<RetType> future = task->get_future();
	{    // 添加任务到队列
		lock_guard<mutex> lock{ _lock };//对当前块的语句加锁  lock_guard 是 mutex 的 stack 封装类，构造的时候 lock()，析构的时候 unlock()
		_tasks.emplace([task](){ // push(Task{...}) 放到队列后面
			(*task)();
		});
	}
#ifdef THREADPOOL_AUTO_GROW
	if (_idlThrNum < 1 && _pool.size() < THREADPOOL_MAX_NUM)
		addThread(1);
#endif // !THREADPOOL_AUTO_GROW
	_task_cv.notify_one(); // 唤醒一个线程执行

	return future;
}

//......

// 执行任务
while (_run)
	{
		Task task; // 获取一个待执行的 task
		{
			// unique_lock 相比 lock_guard 的好处是：可以随时 unlock() 和 lock()
			unique_lock<mutex> lock{ _lock };
			_task_cv.wait(lock, [this]{
					return !_run || !_tasks.empty();
			}); // wait 直到有 task
			if (!_run && _tasks.empty())
				return;
			task = move(_tasks.front()); // 按先进先出从队列取一个 task
			_tasks.pop();
		}
		_idlThrNum--;
		task();//执行任务
		_idlThrNum++;
	}

// 提交一个任务，可以指定线程执行，否则自动分配
	void commit(Task task, int thread_id = -1) {
		if (thread_id > (int)threads_.size() - 1) {
			cout << "Invalid thread id:" << thread_id << endl;
			return;
		}
		if (thread_id == -1)
			thread_id = AllocateThread();
		threads_[thread_id]->Schedule(task);
		g_task_queue_++;
	}