C++ ThreadPool

最新推荐文章于 2024-09-26 12:23:36 发布
最新推荐文章于 2024-09-26 12:23:36 发布
阅读量1.8k 收藏 3
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxxtentac1on/article/details/124517829
版权

线程池

半同步半异步线程池

再处理大量并发任务的时候，如果按照传统的方式，来一个任务请求，对应一个线程来处理请求任务，大量的线程创建和销毁将消耗过多的系统资源，还增加了线程运行环境切换的开销，而通过线程池技术就可以很好地解决这些问题；线程池技术通过再系统中预先创建一定量的线程，当任务请求到来时从线程池中分配一个预先创建的线程去处理任务，线程在处理完任务之后还可以重用，不会销毁，而是等待下次任务的到来

这样，通过线程池能避免大量的线程创建和销毁动作，从而节省系统资源，这样做的一个好处是，对于多核处理器，由于线程会被分配到多个CPU，会提高并行处理的效率；另一个好处是每个线程独立阻塞，可以防止主线程被阻塞而使主流程被阻塞，导致其他的请求得不到相应的问题

线程池分为半同步半异步线程池和领导者追随者线程池，本章主要介绍半同步半异步线程池，这种线程池在实现上更简单，使用得比较多，也比较方便

在这里插入图片描述

  • 半同步半异步线程池分为三层
  1. 同步服务层：它处理来自上层的任务请求，上层的请求可能是并发的，这些请求不是马上就会被处理，而是将这些任务放到一个同步排队层中，等待处理
  2. 同步排队层：来自上层的任务请求都会加到排队层中等待处理
  3. 异步服务层，这一层中会有多个线程同时处理排队层中的任务，异步服务器从同步排队层中取出任务并行的处理

在这里插入图片描述

同步队列

template<typename T>
class  SyncQueue
{

public:
	SyncQueue(int maxSize) :m_max_Size(maxSize), m_needStop(false)
	{}
	void Put(const T& x)
	{
		Add(x);
	}
	void Put(T&& x) //const T &&x 左值常因用，编译器认为不可变，变成具名变量
 	{
		Add(std::forward<T>(x)); //保证x为右值
	}//可接收一切类型
	void Take(std::list<T>& list)
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notEmpty.wait(locker, [this]()->bool {return m_needStop || NotEmpty(); });
		if (m_needStop)
		{
			return;
		}
		list = std::move(m_queue); //取走全部任务
		m_notFull.notify_one();    //唤醒添加任务
	}
	void Take(T& t)
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notEmpty.wait(locker, [this]()->bool {return m_needStop || NotEmpty(); });
		if (m_needStop)
		{
			return;
		}
		t = m_queue.front();
		m_queue.pop_front();
		m_notFull.notify_one();
	}
	void Stop()
	{
		{
			std::unique_lock<std::mutex> locker(m_mutex);
			m_needStop = true;
		}
		m_notFull.notify_all();
		m_notEmpty.notify_all();
	}
	bool Empty()const
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.empty();
	}
	bool Full()const
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.size() = m_max_Size;
	}
	size_t Size()
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.size();
	}
private:
	bool NotFull()const
	{
		bool full = m_queue.size() >= m_max_Size;
		if (full)
		{
			cout << "缓冲区已经满了  m_queue full!" << endl;
		}
		return !full;
	}
	bool NotEmpty()const
	{
		bool empty = m_queue.empty();
		if (empty)
		{
			cout << "m_queue empty!" << endl;
		}
		return !empty;
	}
	template<class F>
	void Add(F&& x) //接收任意类型 并保持值状态
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notFull.wait(locker, [this]()->bool {return m_needStop || NotFull(); });
		m_queue.push_back(std::forward<F>(x)); //入队
		m_notEmpty.notify_one();
	}
private:
	std::list<T> m_queue;
	mutable std::mutex m_mutex;
	std::condition_variable m_notEmpty;   //取事务等待队列
	std::condition_variable m_notFull;    //添加等待队列
	int m_max_Size;    //同步队列max
	bool m_needStop;   //是否停止
};

异步服务层

const int MaxTaskCount = 100;
class ThreadPool
{
public:
	using Task = std::function<void()>; //返回类型为空 无参
	ThreadPool(int numThreads = std::thread::hardware_concurrency()) //返回逻辑核数量
		:m_queue(MaxTaskCount)
	{
		Start(numThreads);
	}
	void Stop()
	{
		std::call_once(m_flag, [this] {StopThreadGroup(); });//终止所有线程
	}
private:
	void Start(int numThreads)
	{
		m_running = true;  //叫停线程
		for (int i = 0; i < numThreads; ++i)
		{
			m_threadgroup.push_back(std::make_shared<thread>(&ThreadPool::RunInThrea,this));
			                                               // & 告诉系统为类型成员，而不是静态成员
		}
	}
	void RunInThrea() 
	{
		while (m_running)
		{
			std::list<Task> list;
			m_queue.Take(list); //取一批事务
			for (auto& task : list)
			{
				if (!m_running)
				{
					return;
				}
				task(); //处理事务
			}
		}
	}
	void StopThreadGroup() //停止线程组线程
	{
		m_queue.Stop();
		m_running = false;
		for (auto& th : m_threadgroup)
		{
			if (th) //智能指针
			{
				th->join();
			}
		}
		m_threadgroup.clear();
	}
	std::list<std::shared_ptr<std::thread>> m_threadgroup; //线程组
	SyncQueue<Task> m_queue;
	atomic_bool m_running; //原子操作
	std::once_flag m_flag; //标记 只执行一次

};

测试代码

template<typename T>
class  SyncQueue
{

public:
	SyncQueue(int maxSize) :m_max_Size(maxSize), m_needStop(false)
	{}
	void Put(const T& x)
	{
		Add(x);
	}
	void Put(T&& x) //const T &&x 左值常因用，编译器认为不可变，变成具名变量
	{
		Add(std::forward<T>(x)); //保证x为右值
	}//可接收一切类型
	void Take(std::list<T>& list)
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notEmpty.wait(locker, [this]()->bool {return m_needStop || NotEmpty(); });
		if (m_needStop)
		{
			return;
		}
		list = std::move(m_queue); //取走全部任务
		m_notFull.notify_one();    //唤醒添加任务
	}
	void Take(T& t)
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notEmpty.wait(locker, [this]()->bool {return m_needStop || NotEmpty(); }); //空队列阻塞 不空继续运行
		if (m_needStop)
		{
			return;
		}
		t = m_queue.front();
		m_queue.pop_front();
		m_notFull.notify_one();
	}
	void Stop()
	{
		{
			std::unique_lock<std::mutex> locker(m_mutex);
			m_needStop = true;
		}
		m_notFull.notify_all();
		m_notEmpty.notify_all();
	}
	bool Empty()const
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.empty();
	}
	bool Full()const
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.size() = m_max_Size;
	}
	size_t Size()
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		return m_queue.size();
	}
private:
	bool NotFull()const
	{
		bool full = m_queue.size() >= m_max_Size;
		if (full)
		{
			cout << "缓冲区已经满了  m_queue full!" << endl;
		}
		return !full;
	}
	bool NotEmpty()const
	{
		bool empty = m_queue.empty();
		if (empty)
		{
			cout << "m_queue empty!" << endl;
		}
		return !empty;
	}
	template<class F>
	void Add(F&& x) //接收任意类型 并保持值状态
	{
		std::unique_lock<std::mutex> locker(m_mutex);
		m_notFull.wait(locker, [this]()->bool {return m_needStop || NotFull(); });
		if (m_needStop)
		{
			return;
		}
		m_queue.push_back(std::forward<F>(x)); //入队
		m_notEmpty.notify_one();
	}
private:
	std::list<T> m_queue;
	mutable std::mutex m_mutex;
	std::condition_variable m_notEmpty;   //取事务等待队列
	std::condition_variable m_notFull;    //添加等待队列
	int m_max_Size;    //同步队列max
	bool m_needStop;   //是否停止


};

const int MaxTaskCount = 10;
class ThreadPool
{
public:
	using Task = std::function<void()>; //返回类型为空 无参
	ThreadPool(int numThreads = std::thread::hardware_concurrency()) //返回逻辑核数量
		:m_queue(MaxTaskCount)
	{
		//Start(numThreads);
	}
	~ThreadPool()
	{
		Stop();
	}
	void Stop()
	{
		std::call_once(m_flag, [this] {StopThreadGroup(); });//终止所有线程
	}
	void AddTask(Task&& task) 
	{
		m_queue.Put(task); //添加事务
	}
	void AddTask(const Task& task)
	{
		m_queue.Put(task); //添加事务
	}
	void Start(int numThreads)
	{
		m_running = true;  //叫停线程
		for (int i = 0; i < numThreads; ++i)
		{
			m_threadgroup.push_back(std::make_shared<thread>(&ThreadPool::RunInThrea, this));
			// & 告诉系统为类型成员，而不是静态成员
		}
	}
private:
	void RunInThrea()
	{
		while (m_running)
		{
			std::list<Task> list;
			m_queue.Take(list); //取一批事务
			for (auto& task : list)
			{
				if (!m_running)
				{
					return;
				}
				task(); //处理事务
			}
		}
	}
	void StopThreadGroup() //停止线程组线程
	{
		m_queue.Stop();
		m_running = false;
		for (auto& th : m_threadgroup)
		{
			if (th) //智能指针
			{
				th->join(); //等待线程停止后，将线程清除掉
			}
		}
		m_threadgroup.clear();
	}
	std::list<std::shared_ptr<std::thread>> m_threadgroup; //线程组
	SyncQueue<Task> m_queue;
	atomic_bool m_running; //原子操作
	std::once_flag m_flag; //标记 只执行一次

};


void* alloc(size_t sz)
{
	void* s = malloc(sz);
	return s;
}
void f()
{
	cout << "f" << endl;
}
void func(ThreadPool& pool)
{
	cout << "void funa" << endl;
	for (int i = 0; i < 100; ++i)
	{
		auto thdid = this_thread::get_id();
		pool.AddTask(f); //需要添加返回类型空 参数空的事务
	}
}
void TestThdPool()
{
	ThreadPool pool;
	std::thread tha(func, std::ref(pool)); //添加事务
	std::thread thb(func, std::ref(pool));
	std::this_thread::sleep_for(std::chrono::seconds(5));
	pool.Start(8);

	tha.join();
}
int main()
{
	TestThdPool();
	return 0;
}

尽管这一步可以成功的运行，但是还是确实一部分，如何对事务的参数的接收以及对返回类型的接收

悲伤土豆拌饭
关注
专栏目录
threadpool c++ 线程池
07-18
threadpool c++
c++ threadpool
黑塞的博客
01-15 1971
ThreadPool c++17 采用多线程多对列,每个线程控制一个队列，替代老的多个线程公用一个队列。 将任务拆分多个下发给每个线程，每个线程掌管 M(tasks) / N(threads)个任务 M(tasks) / N(threads)个任务 公用一个队列。减少竞争。 使用方法： 初始化线程池 ThreadPool pool(4); //4个thread std::vector<std::future<int>>vec; 添加任务 for(int i =0;
详解线程池
最新发布
努力学习游泳的鱼的博客
09-26 877
C++线程池是一种有效的并发编程技术，通过预先创建一组线程来管理并发任务，减少了资源占用和提高了程序性能。实现一个简单的C++线程池涉及任务队列、工作线程、任务提交和线程管理等关键点。线程池的优势在于提高性能、资源利用率高和简化编程。广泛应用于需要并发处理大量任务的场景。
ThreadPool C++实现
08-27
C++ 线程池 资源的有效调度 通过线程池可以实现资源的有限利用，同时防止读写锁。
C++11 ThreadPool:一个易于使用的C ++ 11线程池。-开源
05-15
一个易于使用的C ++ 11线程池。 使用ThreadPool类对自由函数进行排队，并使用std :: for_each（）和std :: transform（）的并行版本。 可配置为仅用于标头或与库一起使用。 有许多用法示例。
C++版ThreadPool实现
Oshyn —— 乐而学，学而乐
07-17 1866
个人基于pthread实现的C++版ThreadPool，代码见github。
threadpool_informationmcb_threadpool_c++threadpool_
09-29
在标题"threadpool_informationmcb_threadpool_c++threadpool_"中，"informationmcb"可能代表信息管理和控制块，而"threadpool"显然是指线程池，"c++threadpool"则表明我们关注的是C++实现的线程池。 C++11引入了对...
C++11 线程池 ThreadPool
12-21
C++11是C++语言的一个重要版本更新，它引入了大量的新特性，其中包括对多线程的支持。线程池（ThreadPool）是一种管理线程资源的有效方式，它在现代并发编程中扮演着至关重要的角色。线程池允许程序预先创建一组线程...
c++threadpool
10-06
引用内容提供了一段C++代码，其中定义了一个线程池类ThreadPool，该线程池类包括了一些成员函数和数据成员用于实现线程池的功能。具体来说，线程池类中包括了一个线程安全的任务队列AQueueThreadSafe，用于存放待...
【转】一个简单的线程池（c++版）
11-08 604
#ifndef _ThreadPool_H_#define _ThreadPool_H_#pragma warning(disable: 4530)#pragma warning(disable: 4786)#include cassert>#include vector>#include queue>#include windows.h>class Thr
ThreadPool:一个简单的C ++线程池实现
05-24
C ++中的线程池 描述 这是C ++中的简单ThreadPool实现。 此实现提供以下功能： 每个池实例的可配置线程数。 动态线程数修改SetThreadCount(size_t) 两种ThreadPool停止模式：同步和异步 main.cpp提供了使用此ThreadPool的示例代码。 ＃＃内容 Makefile ：用于编译库的makefile main.cpp ：使用此ThreadPool库的示例代码 Task.h ：将由线程执行的任务的抽象接口 ThreadPoolTask.cpp ：threadPool库的实现 ThreadPoolTask.h ：threadPool库的API ＃＃要求 Boost 1.48.0（用于boost :: functions） GNU Make 3.81或更高版本 G ++ 4.7.2
线程池c++实现
f593256的博客
01-20 1146
线程池（Thread Pool）是一种并发编程的设计模式，它用于管理和重复使用线程，以提高程序的性能和资源利用率。线程池通过维护一组预先创建的线程，这些线程可以在需要时被重复使用，而不是为每个任务都创建一个新的线程。线程池通常包含以下主要组件用于存储待执行的任务。当有新的任务到达时，它被放入任务队列中等待执行。一组预先创建的线程，它们在整个程序的生命周期内一直存在。这些线程从任务队列中获取任务，并执行任务的操作。负责管理线程池的创建、销毁和任务分配等工作。
线程池 - C++
生活需要深度
05-04 2619
// project4.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <vector> #include <map> #include <string> #include <thread> #include <list> #include <mutex> #include <future> using name.
C++ 线程池
落雨碎江南
08-21 2859
c++线程池详解，创作不易，路过的点个赞！！！
【C++】基于C++11的线程池：threadpool
郭老二
01-01 1719
C++线程池
ThreadPool线程池的C++实现
墨1024
11-18 1668
线程池 threadpool 的C++实现，
C++线程池-ThreadPool
YangGangAVA的博客
10-22 1069
今天介绍一下线程池，线程池还是比较简单的，使用线程函数开辟几条线程，每条线程使用一个循环检测任务队列，当有任务时执行，这里为了避免CPU的空转，当有新任务加入队列时，通知一个线程去执行它。 这个线程池具有以下特点： 1、定时检测线程数量，关闭空闲的多余线程； 2、像最大线程数，保持线程数是可以在运行时改变的，虽然基本上没有这个必要； 3、这个线程池是单例的，我在使用时会在程序启动时创建它，然
[C++11] ThreadPool
sai_j的博客
10-16 573
背景 近期，在造一个异步HTTP调用的轮子；https://github.com/Sai-Jiang 简单来说，通过一个Restful接口，代理会接收异步HTTP调用的请求； 这些接收到的异步HTTP调用请求，将会由代理代为去执行； 适用的场景，主要是低时延接口调用高时延接口； HTTP的调用，目前准备用线程池来做； 线程池实现中的任务队列，我就直接复用了之前博客中的BoundedBl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值