C++简易线程池

最新推荐文章于 2024-03-22 16:27:07 发布
最新推荐文章于 2024-03-22 16:27:07 发布
阅读量499 收藏 8
点赞数 9
分类专栏： C++ 文章标签： c++ 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gdizcm/article/details/135309500
版权

原理说明：

1. 线程池创建时，指定线程池的大小thread_size。当有新的函数任务通过函数addFunction ()添加进来后，其中一个线程执行函数。一个线程一次执行一个函数。如果函数数量大与线程池数量，则后来的函数等待。

2. 线程池内部有个容器m_functions 来存储待执行的函数。函数执行后从队列中移除。

3.  stopAll()函数会停止线程池。

ThreadPool.h

//ThreadPool.h
#include <condition_variable>
#include <cstddef>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

class ThreadPool {
public:
	static ThreadPool* getInstance(size_t thread_size = 1);		//默认线程池大小
	void addFunction(std::function<void()> task);				//添加需要执行的函数
	~ThreadPool();

	void stopAll(bool immediately);						//停止线程池， immediately:true立即停止， immediately:false等待当前线程函数执行完后停止。
private:
	ThreadPool(size_t thread_size);

private:
	void workerThreadHandler();
	std::vector<std::thread> m_workers;					//线程容器
	std::queue<std::function<void()>> m_functions;			//待执行的函数容器
	std::mutex m_queue_mutex;
	std::condition_variable m_condition;
	bool m_stop;										//线程池停止状态

	std::thread m_wakeTimerThread;
	std::mutex m_timer_mutex;
};

ThreadPool.cpp

#include "ThreadPool.h"
#include <chrono>
#include <memory>
#include <thread>
#include <pthread.h>
#include <iostream>
using namespace std;

ThreadPool* ThreadPool::getInstance(size_t thread_size)
{
	static std::mutex m_lock;
	static std::shared_ptr<ThreadPool> m_instance=nullptr;
	if (nullptr == m_instance)
	{
		m_instance.reset(new ThreadPool(thread_size));
	}
	return m_instance.get();
}
ThreadPool::ThreadPool(size_t thread_size) : m_stop(false){
	m_workers.reserve(thread_size);
	for (size_t i=0; i<thread_size; ++i)
	{
		m_workers.emplace_back([this, i](){	//创建线程池中的线程
		workerThreadHandler();
		});
	}

	//辅助线程，每隔一段时间发送一次唤醒，防止线程阻塞
	m_wakeTimerThread = std::thread([this](){	
		for(;!this->m_stop;)
		{
			std::unique_lock<std::mutex> lock(this->m_timer_mutex);
			std::this_thread::sleep_for(std::chrono::milliseconds(2000));

			pthread_testcancel();

			m_condition.notify_all();
			std::cout<<"wake up"<<std::endl;
		}

	});
	std::cout<<__func__<<std::endl;
}


//线程循环函数，循环查询函数容器是否为空，不为空则读取一个函数并执行。
void ThreadPool::workerThreadHandler()	
{
	for (;!this->m_stop;){
		std::function<void()> task;
	{
		std::unique_lock<std::mutex> lock(this->m_queue_mutex);
		std::cout<<"tasks begin size:"<<this->m_functions.size()<<" stop:"<<m_stop<<std::endl;
		if (!m_stop && m_functions.empty())
		{
			this->m_condition.wait(lock);
		}

		pthread_testcancel();	//作为线程的终止点

		if (this->m_stop)
		{
			return;
		}
		if (this->m_functions.empty())
		{
			continue;
		}
		task = std::move(this->m_functions.front());
		this->m_functions.pop();
		std::cout<<std::this_thread::get_id() <<" tasks end size:"<<this->m_functions.size()<<std::endl;
	}
	task();
	std::cout<<__func__<<" end task"<<std::endl;
	std::this_thread::sleep_for(std::chrono::milliseconds(200));
	}
}

void ThreadPool::addFunction(std::function<void()> task)	//添加待执行的函数
{
	std::unique_lock<std::mutex> lock(m_queue_mutex);

	if (m_stop){
	return;
	}
	m_functions.emplace(std::move(task));
	m_condition.notify_one();
}

ThreadPool::~ThreadPool()
{
	{
		std::unique_lock<std::mutex> lock(m_queue_mutex);
		m_stop = true;
	}
	m_condition.notify_all();
	for (std::thread &worker: m_workers)
	{
		worker.join();
	}
	m_wakeTimerThread.join();
	std::cout<<__func__<<std::endl;
}

void ThreadPool::stopAll(bool immediately)	//停止线程， immediately:true立即停止
{
	this->m_stop = true;
	if (immediately)
	{
		for (std::thread &worker: m_workers)
		{
			pthread_cancel(worker.native_handle());
		}
		pthread_cancel(m_wakeTimerThread.native_handle());
	}
}

测试程序main.cpp

#include <iostream>
#include <chrono>
#include <mutex>
#include "ThreadPool.h"

using namespace std;

static std::mutex m_mutex;
void ProcessFunc111()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(3));
	std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc222()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(4));
	std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc333()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(4));
	std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc444()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(4));
	std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc555()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(4));
	std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc666()
{
	std::cout<<__func__<<" begin"<<std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(3));
	std::cout<<__func__<<" end"<<std::endl;
}

int main()
{
	ThreadPool::getInstance(5);
	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc111();
	});

	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc222();
	});

	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc333();
	});

	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc444();
	});

	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc555();
	});

	ThreadPool::getInstance()->addFunction([](){
		ProcessFunc666();
	});
	getchar();
	return 0;
}

执行结果：

tasks begin size:0 stop:0
ThreadPooltasks begin size:
0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
140563906656000 tasks end size:2
ProcessFunc111 begin
140563898263296 tasks end size:4
ProcessFunc222 begin
140563881477888 tasks end size:3
ProcessFunc333 begin
140563743504128 tasks end size:2
ProcessFunc444 begin
140563889870592 tasks end size:1
ProcessFunc555 begin
wake up
ProcessFunc111 end
workerThreadHandler end task
tasks begin size:1 stop:0
140563906656000 tasks end size:0
ProcessFunc666 begin
ProcessFunc222 end
wake up
workerThreadHandler end task
ProcessFunc333ProcessFunc555ProcessFunc444 end
 endworkerThreadHandler end task

workerThreadHandler end task
 end
workerThreadHandler end task
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
wake up
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
ProcessFunc666 end
workerThreadHandler end task
tasks begin size:0 stop:0
wake up
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
...

测试程序2,调用线程池停止程序

#include <iostream>
#include <chrono>
#include <mutex>
#include "ThreadPool.h"

using namespace std;

static std::mutex m_mutex;
void ProcessFunc111()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc222()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc333()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc444()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc555()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc666()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout<<__func__<<" end"<<std::endl;
}

int main()
{
    ThreadPool::getInstance(5);
    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc111();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc222();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc333();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc444();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc555();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc666();
    });
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout<<"stop all "<<std::endl;
    ThreadPool::getInstance()->stopAll(false);
    getchar();


    return 0;
}

执行结果：

tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:ThreadPool0 stop:0

tasks begin size:0 stop:0
140190941017856 tasks end size:5
ProcessFunc111 begin
140190932625152 tasks end size:4
ProcessFunc222 begin
140190966195968 tasks end size:3
ProcessFunc333 begin
140190949410560 tasks end size:2
ProcessFunc444 begin
140190957803264 tasks end size:1
ProcessFunc555 begin
stop all
wake up
ProcessFunc111 end
workerThreadHandler end task
ProcessFunc444 end
workerThreadHandler end task
ProcessFunc333 end
workerThreadHandler end task
ProcessFunc222 end
workerThreadHandler end task
ProcessFunc555 end
workerThreadHandler end task

测试程序3，立即停止线程池

#include <iostream>
#include <chrono>
#include <mutex>
#include "ThreadPool.h"

using namespace std;

static std::mutex m_mutex;
void ProcessFunc111()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc222()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc333()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc444()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc555()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    std::cout<<__func__<<" end"<<std::endl;
}

void ProcessFunc666()
{
    std::cout<<__func__<<" begin"<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout<<__func__<<" end"<<std::endl;
}

int main()
{
    ThreadPool::getInstance(5);
    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc111();
    });
    
    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc222();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc333();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc444();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc555();
    });

    ThreadPool::getInstance()->addFunction([](){
        ProcessFunc666();
    });
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout<<"stop all "<<std::endl;
    ThreadPool::getInstance()->stopAll(true);
    getchar();

return 0;
}

执行结果：

tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
tasks begin size:0 stop:0
ThreadPool
139831215929088 tasks end size:5
ProcessFunc111 begin
tasks begin size:5 stop:0
139831199143680 tasks end size:4
ProcessFunc222 begin
139831224321792 tasks end size:3
ProcessFunc333 begin
139831207536384 tasks end size:2
ProcessFunc444 begin
139831232714496 tasks end size:1
ProcessFunc555 begin
stop all

gdizcm
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现线程池
Sison_w的博客
07-19 506
目录 1、为什么需要线程池 2、线程池实现方法 3、了解C++关于多线程的知识 4、源码展示 5、测试函数 6、主函数运行 7、编译错误 8、程序运行 9、在Liunx上编译运行 1、为什么需要线程池 为了减少创建和销毁线程的次数，让每个线程可以多次使用,可根据系统情况调整执行的线程数量，防止消耗过多内存,所以 我们可以使用线程池. 2、线程池实现方法 线程池的内...
C++实现简单线程池
weixin_42224652的博客
04-03 137
C++简单易用线程池 线程模板类功能 start 启动线程池 stop 停止线程池 setThreadCount 设置线程数量 addTask 添加线程任务 (使用 std::function) threadSize 获取线程数量 taskSize 获取任务队列数量 workThreadSize 获取工作线程数 leisureThreadSize 获取空闲线程数 #ifndef THREADPOOL_H #define THREADPOOL_H #include <thread> #in
c++实现简易线程池
最新发布
m0_54505821的博客
03-22 114
【代码】c++实现简易线程池。
基于c++11,14,17新特性的线程池
qq_43804905的博客
04-08 368
线程池的优势就是（每个池都有自己的优势），在服务进程启动之初，就事先创建好线程池里面的线程，当业务流量到来时需要分配线程，直接从线程池中获取一个空闲线程执行task任务即可，task执行完成后，也不用释放线程，而是把线程归还到线程池中继续给后续的task提供服务。线程池里面的线程个数是可动态增长的，根据任务的数量动态的增加线程的数量，但是会设置一个线程数量的阈值（线程过多的坏处上面已经讲过了），任务处理完成，如果动态增长的线程空闲了60s还没有处理其它任务，那么关闭线程，保持池中最初数量的线程即可。
C++11 简单实现线程池的方法
12-16
什么是线程池 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。 不使用线程池有哪些弊端 创建太多线程，将会浪费一定的资源，有些线程未被充分使用。 销毁太多线程，将导致
详解C++17线程池的实现
人世如潮人如水的博客
03-30 4390
C++标准库在C++11之后新增了线程特性，C++的线程在此之后可以进行跨平台使用。在其他的OOP语言(例如Java、C#等)中有线程池来避免过多过频创建线程，提升了不少的性能，在网络库中也有用到线程池的情况，因此了解一个线程池的实现可以更加熟悉多线程的使用。本文将用C++17实现一个简单的线程池，github地址：https://github.com/Invictus2/Thread...
C++17 线程池类
独孤过的博客
10-23 2416
线程池是一种池化资源技术，也是一种多线程模式。线程池调度线程执行任务，通常序列化任务，形成任务队列。 调度的关键在于条件变量。当不满足执行条件时，阻塞线程以让出处理器，在满足条件之前，不占用处理器，以提高资源利用率。 线程池提供设置容量方法，由守护线程异步增删工作线程。当任务队列非空时，一次性增加工作线程；当存在闲置工作线程时，逐个删减工作线程。
C++线程池简单实现
weixin_66448649的博客
06-30 5085
线程池: 当进行并行的任务作业操作时，线程的建立与销毁的开销是，阻碍性能进步的关键，因此线程池，由此产生。使用多个线程，无限制循环等待队列，进行计算和操作。帮助快速降低和减少性能损耗。 线程池的主要组成有上面三个部分：..................
c++简易线程池
07-07
标题"简易线程池"暗示这是一个简单的实现，可能适合初学者学习和理解线程池的工作原理。线程池的实现通常包括以下几个关键组件： 1. **任务队列**：线程池维护一个任务队列，用于存放待处理的任务。任务可以是函数...
这是一个使用C++实现的简易线程池.zip
03-08
这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易线程池.zip这是一个使用C++实现的简易...
C++11 简易线程池实现
03-15
简易的C++11线程池实现，线程池为固定方式，后面会新增非固定模式。
linux C++ 实现线程池（避免线程创建的耗时）
05-22
在Linux环境下，C++编程中实现线程池是一种优化多线程程序性能的重要技术。线程池通过预先创建一组线程来处理任务，避免了频繁地创建和销毁线程带来的开销，从而提高了系统的效率。以下是对这个话题的详细解释。 1....
C++线程池案例实现讲解及参考
欧特GO
08-18 797
C++线程池案例实现讲解及参考，提供多种实现方式源码
九、Linux系统编程：线程池编程
小脑斧的博客
05-26 214
线程池编程
C++11封装线程池(2)
hyl999的专栏
05-21 1256
先上代码，代码来自GitHub。这段代码用了大量C++ 11新特性，并且非常晦涩难懂，接下来会对每个细节逐个解释。 ThreadPool.h #ifndef THREAD_POOL_H #define THREAD_POOL_H #include <vector> #include <queue> #include <memory> #include <thread> #include <mutex> #include <condit
C++ 11 实现简单线程池
qq_40788199的博客
08-21 839
C++11使用新特性，实现最简单都线程池，详细注释
c++实现简单的线程池
万里归来少年心
01-14 909
线程池，先创建一定数目的线程，初始都处于空闲状态。当有新的任务进来，从线程池中取出一个空闲的线程处理任务，处理完成之后，该线程被重新放回到线程池中。当线程池中的线程都在处理任务时，若有新的任务产生，只能等待，直到线程池中有线程结束任务空闲才能执行。 用c++实现固定线程数的线程池。 #include <mutex> #include <condition_va...
nlohmann json简单用法，C++使用json, json与string转换使用笔记
热门推荐
gdizcm的专栏
11-12 1万+
C++解析json时，使用nlohmann json工具解析方便快捷。把它记录下来，方便以后查阅。
Linux C++ 实现动态线程池
"本文档主要介绍了如何在Linux环境下使用C++实现线程池，以及线程池的重要性和优势。线程池提供了一种高效管理线程的方式，可以动态调整线程数量，降低线程创建和销毁的开销，适用于处理大量短生命周期的任务。文中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值