C++线程池，将类方法引入线程池

C++线程池，将类方法引入线程池

使用线程的改变可以提高速度。但是如果一味的提升速度而不断的申请线程，则可能会出现计算机资源耗尽的情况。所以提出线程池的概念。

线程池的概念是提前申请一块内存用于保存一定数量的线程，然后根据任务分配线程。如果任务数量大于线程池中线程的数量，则可以引入队列等概念，将任务排队。直到出现空闲线程时，再根据队列中任务的优先级，将任务分配给线程。

如果使用动态线程，申请线程空间需要时间，而且可能会出现线程过度掠夺资源情况。所以在有较多线程时尽量使用线程池进行优化。

1. 建立线程池类

线程池类参考博客：

C++实现线程池

类代码如下所示：

// ThreadPool.h
#ifndef THREAD_POOL_H
#define THREAD_POOL_H

#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <stdexcept>
//#include "source/AStar.hpp"
class ThreadPool {

public:
	ThreadPool(size_t);                          //构造函数
	template<class F, class... Args>             //类模板
	auto enqueue(F&& f, Args&&... args)->std::future<typename std::result_of<F(Args...)>::type>;//任务入队
	~ThreadPool();                              //析构函数

private:
	std::vector< std::thread > workers;            //线程队列，每个元素为一个Thread对象
	std::queue< std::function<void()> > tasks;     //任务队列，每个元素为一个函数对象    

	std::mutex queue_mutex;                        //互斥量
	std::condition_variable condition;             //条件变量
	bool stop;                                     //停止
};

// 构造函数，把线程插入线程队列，插入时调用emplace_back()，用匿名函数lambda初始化Thread对象
inline ThreadPool::ThreadPool(size_t threads) : stop(false) {

	for (size_t i = 0; i < threads; ++i) {
		workers.emplace_back([this]() {
			for (;;)
			{
				// task是一个函数类型，从任务队列接收任务
				std::function<void()> task;
				{
					//给互斥量加锁，锁对象生命周期结束后自动解锁
					std::unique_lock<std::mutex> lock(this->queue_mutex);

					//（1）当匿名函数返回false时才阻塞线程，阻塞时自动释放锁。
					//（2）当匿名函数返回true且受到通知时解阻塞，然后加锁。
					this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });

					if (this->stop && this->tasks.empty())
						return;

					//从任务队列取出一个任务
					task = std::move(this->tasks.front());
					this->tasks.pop();
				}                            // 自动解锁
				task();                      // 执行这个任务
			}
		}
		);
	}

}

// 添加新的任务到任务队列
template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args)
-> std::future<typename std::result_of<F(Args...)>::type>
{
	// 获取函数返回值类型        
	using return_type = typename std::result_of<F(Args...)>::type;

	// 创建一个指向任务的智能指针
	auto task = std::make_shared< std::packaged_task<return_type()> >(
		std::bind(std::forward<F>(f), std::forward<Args>(args)...)
		);

	std::future<return_type> res = task->get_future();
	{
		std::unique_lock<std::mutex> lock(queue_mutex);  //加锁
		if (stop)
			throw std::runtime_error("enqueue on stopped ThreadPool");

		tasks.emplace([task]() { (*task)(); });          //把任务加入队列
	}                                                   //自动解锁
	condition.notify_one();                             //通知条件变量，唤醒一个线程
	return res;
}

// 析构函数，删除所有线程
inline ThreadPool::~ThreadPool()
{
	{
		std::unique_lock<std::mutex> lock(queue_mutex);
		stop = true;
	}
	condition.notify_all();
	for (std::thread &worker : workers)
		worker.join();
}

#endif

参考博客中有对代码以及使用方法的详细解读，详细请阅读参考博客。

2. 使用其他类定义的方法进行多线程

上述的参考博客中使用线程池的方法是使用函数。

// main.cpp
#include <iostream>
#include "ThreadPool.h"
 
void func()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout<<"worker thread ID:"<<std::this_thread::get_id()<<std::endl;
}
 
int main()
{
    ThreadPool pool(4);
    while(1)
    {
       pool.enqueue(fun);
    }
}

可以看出，声明ThreadPool类后，将调用的函数引入队列中即可使用多线程。但如果使用的是类中的方法则会报错。

// main.cpp
#include <iostream>
#include "ThreadPool.h"
#include "source/AStar.hpp"
 
int main()
{
    ThreadPool pool(4);
    AStar::Generator generator;
    
    for (int i = 0; i < end.size(); ++i) {
		pool.enqueue(generator.findPath, start, end[i], upper_left, lower_right, alpha);
	}
}

上述代码隐藏了Astar.hpp代码的使用，其实现的是使用A*算法求解路径。pool.enqueue()中的第一个参数是多线程的函数，第二个参数以后是多线程函数的参数。

上述代码会出现错误。

倘若将代码加上&，则会报错。

pool.enqueue(&generator.findPath, start, end[i], upper_left, lower_right, alpha);

3. 解决类对象方法错误

查阅相关资料，得到结果。参考博客为：

类成员函数作为函数参数出现error C3867:非标准语法；请使用“&”来创建指向成员的指针

错误原因主要是因为类对象中有this指针，而泛函中不能使用this指针（线程池的类实现中使用了模板类）。

所以使用另一个类的函数设为静态，这样既可以不用this指针了。

// 类定义
// AStar.hpp
class GeneratorAdapter
	{
	private:
		Generator *t;
	public:
		GeneratorAdapter(Generator *t_) :t(t_) {}
		CoordinateList operator()(Vec2i source_, Vec2i target_, Vec2i upper_left_, Vec2i lower_right_, int alpha);
	};

// 类实现
// AStar.cpp
AStar::CoordinateList AStar::GeneratorAdapter::operator()(Vec2i source_, Vec2i target_, Vec2i upper_left_, Vec2i lower_right_, int alpha)
{
	return t->findPath(source_, target_, upper_left_, lower_right_, alpha);
}

// 类引用
// main.cpp
AStar::GeneratorAdapter ad(&generator);
pool.enqueue(ad, start, end[i], upper_left, lower_right, alpha)

使用上述方法可以实现多线程的使用。

4. 结果输出

使用多线程的最终目的是并行实现多个函数，函数必定有输出。需要将并行的结果输出出来。

使用本方法的弊端是将子线程与主函数的父线程分离开，即申请完子线程之后父线程（主函数）继续运行。父线程运行结束后子线程不会销毁，直到子线程运行结束才会销毁。所以需要在父线程加入等待子线程结束才能继续运行的代码。

通过阅读ThreadPool.h可以看出，pool.enqueue的返回值是一个std::future，std::future需要使用get()方法去除其中的数据。所以实现思路是：申请完线程后，遍历所有线程，使用get将结果取出。

// main.cpp
std::vector<std::future<AStar::CoordinateList>> path;
	for (int i = 0; i < end.size(); ++i) {
		path.push_back(pool.enqueue(ad, start, end[i], upper_left, lower_right, alpha));
	}
	for (int i = 0; i < end.size(); ++i) {
		auto a = path[i].get();
	}

将pool的返回值引入vector中，申请完线程后使用get()方法等待线程运行结束。全部线程运行结束后在执行主函数的后续程序。

5. 参考

线程中常用的锁，有哪几种

C++多线程编程：基于现代C++的多线程库

C++11之std::future对象使用说明