c++线程池简单实现

多线程技术主要是解决单个处理器单元内多个线程的执行问题，由此诞生了所谓的线程池技术。

线程池基本部分组成：

1.线程池管理器（Thread Pool）：负责创建、管理线程池，最基本的操作为：创建线程池、销毁线程池、增加新的线程任务；

2.工作线程（Worker）：线程池中的线程，在没有任务时会处于等待状态，可以循环执行任务；

3.任务队列（Tasks Queue）：未处理任务的缓存队列，提供一种缓冲机制。

4.任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。 
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

为了更深刻的理解线程池这项技术，我们来看一个实际点的例子。

在 Web 服务器中，如果一天中服务器需要处理一百万个请求，并且每个请求都需要让一个独立的线程完成。为了保证服务器任务执行的高效性（能执行的赶紧执行），不应该让并发执行的线程数无节制的增长，所以，线程池在这其中就发挥了作用。

考虑一个处理器完成一项任务会分为创建线程、线程执行任务和销毁线程三个阶段。如果在某个访问高峰期同时出现了十万的并发请求，且每个任务的请求都很简单，甚至执行任务的时间还小于这个线程被创建的时间，那么这时处理器必须花费大量的时间来创建这些请求的线程，而很长时间内让

各个线程得不到执行。有了线程池之后，我们可以在程序启动后创建一定数量的线程，当任务到达后，缓冲队列会将任务加入到线程中进行执行，执行完成后，线程并不销毁，而是等待下一任务的到来。

线程池工作原理：

主线程和工作线程之间通过一个共享的工作队列来同步，工作线程睡眠在工作队列上。当有新的任务到来时，主线程将新的任务添加到工作队列中。

这将唤醒正在等待任务的工作线程，不过只有一个工作线程会获得新任务的”接管权”，他可以从工作队列中取出任务并执行。而其他的工作线程则继续睡眠在工作队列上。

由于主线程和工作线程之间有一个工作队列，所以主线程和工作线程之间没有耦合性，主线程往工作队列中插入任务，睡眠的工作线程通过竞争来取得任务并执行它。
 

代码示例：

#ifndef ThreadPool_h
#define ThreadPool_h

#include 
#include 
#include 
#include 
#include 
#include 
#include 

class ThreadPool {
public:
ThreadPool(size_t); //构造函数，size_t n 表示连接数

template
auto enqueue(F&& f, Args&&... args) //任务管道函数
-> std::future::type>; //利用尾置限定符 std future用来获取异步任务的结果

~ThreadPool();
private:
// need to keep track of threads so we can join them
std::vector< std::thread > workers; //追踪线程
// the task queue
std::queue< std::function > tasks; //任务队列，用于存放没有处理的任务。提供缓冲机制

// synchronization 同步？
std::mutex queue_mutex; //互斥锁
std::condition_variable condition; //条件变量？
bool stop;
};

// the constructor just launches some amount of workers
inline ThreadPool::ThreadPool(size_t threads): stop(false)
{
for(size_t i = 0;i task; //线程中的函数对象
{//大括号作用：临时变量的生存期，即控制lock的时间
std::unique_lock lock(this->queue_mutex);
this->condition.wait(lock,
[this]{ return this->stop || !this->tasks.empty(); }); //当stop==false&&tasks.empty(),该线程被阻塞 !this->stop&&this->tasks.empty()
if(this->stop && this->tasks.empty())
return;
task = std::move(this->tasks.front());
this->tasks.pop();

}

task(); //调用函数，运行函数
}
}
);
}

// add new work item to the pool
template
auto ThreadPool::enqueue(F&& f, Args&&... args) //&& 引用限定符，参数的右值引用， 此处表示参数传入一个函数
-> std::future::type>
{
using return_type = typename std::result_of::type;
//packaged_task是对任务的一个抽象，我们可以给其传递一个函数来完成其构造。之后将任务投递给任何线程去完成，通过
//packaged_task.get_future()方法获取的future来获取任务完成后的产出值
auto task = std::make_shared >( //指向F函数的智能指针
std::bind(std::forward(f), std::forward(args)...) //传递函数进行构造
);
//future为期望，get_future获取任务完成后的产出值
std::future res = task->get_future(); //获取future对象，如果task的状态不为ready，会阻塞当前调用者
{
std::unique_lock lock(queue_mutex); //保持互斥性，避免多个线程同时运行一个任务

// don't allow enqueueing after stopping the pool
if(stop)
throw std::runtime_error("enqueue on stopped ThreadPool");

tasks.emplace([task](){ (*task)(); }); //将task投递给线程去完成，vector尾部压入
}
condition.notify_one(); //选择一个wait状态的线程进行唤醒，并使他获得对象上的锁来完成任务(即其他线程无法访问对象)
return res;
}//notify_one不能保证获得锁的线程真正需要锁，并且因此可能产生死锁

// the destructor joins all threads
inline ThreadPool::~ThreadPool()
{
{
std::unique_lock lock(queue_mutex);
stop = true;
}
condition.notify_all(); //通知所有wait状态的线程竞争对象的控制权，唤醒所有线程执行
for(std::thread &worker: workers)
worker.join(); //因为线程都开始竞争了，所以一定会执行完，join可等待线程执行完
}



#endif /* ThreadPool_h */

主程序如下：

#include 
#include 
#include 

#include "ThreadPool.h"

int main()
{

ThreadPool pool(4);
std::vector< std::future > results;

for(int i = 0; i < 8; ++i) {
results.emplace_back(
pool.enqueue([i] {
std::cout << "hello " << i << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "world " << i << std::endl;
return i*i;
})
);
}

for(auto && result: results) //通过future.get()获取返回值
std::cout << result.get() << ' ';
std::cout << std::endl;

return 0;
}

运行结果：