C++实现线程池

最新推荐文章于 2024-05-09 08:14:34 发布
最新推荐文章于 2024-05-09 08:14:34 发布
阅读量479 收藏
点赞数
分类专栏： c++ 并发 文章标签： c++ 线程池 线程安全 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44093765/article/details/120116713
版权

c++实现线程池

本文将不会使用C++不易理解的特性，将使用最基本的c++语法实现一个线程对象以及线程池，
完整工程见：https://github.com/wk-xjd/wkthreadpool

自旋锁类

#ifndef WKLOCKER_H
#define WKLOCKER_H
#include <mutex>
#include <atomic>
#include <condition_variable>

class WKLocker
{
public:
	WKLocker(int spinTimes = 20);
	~WKLocker();
	
	void lock();
	void unlock();

private:
	std::atomic<unsigned int> m_currentThreadId = 0;
	std::condition_variable m_condition;
	int m_lockCount = 0;
	std::mutex m_muetex;
	unsigned int m_exceptValue = 0;
	int m_spinCount;
	std::atomic<bool> m_delete = false;
};

#endif

#include "WKLocker.h"
#include "utils.h"

WKLocker::WKLocker(int spinTimes)
	: m_spinCount(spinTimes)
{

}
WKLocker::~WKLocker()
{
	m_delete = true;
	m_condition.notify_all();
}

void WKLocker::lock()
{
	unsigned int curThrId = WKUtils::currentThreadId();
START_GET_LOCK:
	{
		//自旋
		std::atomic<int> currCount = m_spinCount;
		while (!m_currentThreadId.compare_exchange_weak(m_exceptValue, curThrId))
		{
			if (!currCount.fetch_sub(1))
				break;
		}
		//自旋失败获取锁失败则阻塞
		if (m_currentThreadId == curThrId)
		{
			m_lockCount++;	//重入
		}
		else
		{
			std::unique_lock<std::mutex> locker(m_muetex);
			m_condition.wait(locker, [&]()
				{return m_currentThreadId == m_exceptValue; });
			locker.unlock();
			//锁被让出后，重新获取锁
			if (!m_delete)
				goto START_GET_LOCK;
		}
	}
}

void WKLocker::unlock()
{
	unsigned int curThrId = WKUtils::currentThreadId();

	if (m_currentThreadId == curThrId)
	{
		if (!(--m_lockCount))
		{
			//锁释放后唤醒所有阻塞在该锁的线程
			m_currentThreadId = m_exceptValue;
			m_condition.notify_all();
			m_lockCount = 0;
		}
	}
}

线程任务类

通过添加任务的方式启动在新线程中执行，则需要继承该线程任务类

#ifndef WKTHREAGTASK_H
#define WKTHREAGTASK_H

/*
	线程任务基类（抽象类）
	1.任务入口：重写纯虚函数run函数，
	2.任务结束回调入口：重写虚函数callback函数
	3.任务有三个优先级（PriortyLevel），默认为LOW，将任务添加到线程池任务队列时，会优先处理高优先级任务
	4.getTaskId（虚函数可重写），默认使用实例对象的地址的hashcode
	5.可以设置m_autoDelete属性，任务执行结束后是否自动释放该对象，若为ture，一定要重写析构函数
*/
class WKThreadTask
{
public:
	enum PriortyLevel
	{
		Low,
		Middle,
		Hight,
	};
	WKThreadTask() {};
	virtual ~WKThreadTask() {};
	virtual void run() = 0;
	virtual void callback() {};
	virtual unsigned int getTaskId() { return hash_task_fn(this); }
	PriortyLevel taskPriorty() { return m_priorty; }
	void setTaskPriorty(PriortyLevel level) { m_priorty = level; }
	bool isAutoDelete() { return m_autoDelete; } const
	void setAutoDelete(const bool isAutoDeleted = false) { m_autoDelete = isAutoDeleted; }
private:
	std::hash<WKThreadTask*> hash_task_fn;
	unsigned int m_taskId = 0;
	PriortyLevel m_priorty = PriortyLevel::Low;
	bool m_autoDelete = false;
};

#endif //WKTHREAGTASK_H

线程类

#pragma once
#ifndef WKThread_H
#define WKThread_H

#include <thread>
#include <atomic>
#include <mutex>   
#include <deque>
#include <condition_variable>
#include "WKLocker.h"

class WKThreadTask;

/*
	WKThread线程类使用方式：
	1.继承WKThread类，并重写run方法，
		通过start方法启动线程并执行，线程执行完毕自动释放该线程
	2.实例化WKThread对象，并将继承了WKThreadTask的线程任务添加到线程，
		2.1 通过start方法启动线程，
		2.2 线程任务执行完毕后，线程不会立即释放，
		2.3 线程任务执行完毕后进入挂起状态，等待下一次添加任务唤醒
		2.4 线程随实例化对象释放而释放，也可以通过quit方法释放线程
*/
class WKThread
{
public:
	enum ThreadState
	{
		Running,
		Finished,
		Waiting,
	};
	WKThread();
	virtual ~WKThread();
	void start();	//启动线程
	void quit();	//退出线程
	void wake();	//唤醒线程
	void wait();	//挂起线程
	bool addTask(WKThreadTask* task);	//添加线程任务，并唤醒线程，返回任务是否添加成功
	void setNextTaskQueue(std::deque<WKThreadTask*>* nextTaskQueue);	//传递一个任务队列，当前线程任务执行完毕后自动从任务队列中取任务
	void removeNextTaskQueue();	//移除任务队列
	const bool hasNextTaskQueue();	//是否有任务队列

	WKThread* getInstance();	//获取当前线程对象地址
	unsigned int getThreadId() const;	//获取线程id

	bool isRunning() const;	//当前线程是否正在运行
	bool isFinished() const;	//线程任务是否执行完成
	bool isWaiting() const;	//线程是否处于挂起等待状态

protected:
	virtual void run();	//线程执行（用户）任务入口，若该方法未被重写使用方式2创建线程任务，否则使用方式1

private:
	void _runTask();	//通过std库获取到的线程入口
	void _updateState(ThreadState state);	//更新线程状态

private:
	std::thread* m_stdThread = nullptr; 
	std::atomic<bool> m_bWaitFlag = false;
	std::atomic<bool> m_bQuitFlag = true;
	std::atomic<enum ThreadState> m_state = ThreadState::Waiting;
	std::mutex m_mutex;
	std::condition_variable m_condition;
	unsigned int m_threadId = 0;
	WKThreadTask* m_task = nullptr;
	WKLocker m_wkLocker;	//状态锁
	WKLocker m_nextQueueWKLocker;	//队列锁
	std::deque<WKThreadTask*>* m_nextTaskQueue = nullptr;
};
#endif // WKThread_H

线程池类

#include <queue>
#include <thread>
#include <atomic>
#include <deque>
#include <mutex>
#include <condition_variable>
#include "WKLocker.h"

class WKThread;
class WKThreadTask;
/*
	线程池
	1.懒创建线程，有任务且线程数小于最大线程数时创建新的线程
	2.动态调整轮询检查线程状态的间隔
*/
class WKThreadPool
{
public:
	WKThreadPool();	
	WKThreadPool(int maxThreadSize, int maxTaskSize);
	~WKThreadPool();
	void start();	//启动线程池
	void stop();	//停止线程池,停止加入任务
	bool isStop() const;	//线程池是否被终止
	bool addTask(WKThreadTask* task);	//添加任务，返回任务添加结果
	int waitThreadCount() const; 	//挂起等待线程数
	int doneThreadCount() const; 	//运行工作线程数
	int maxThreadSize() const;	//最大线程数
	int maxTaskSize() const;	//最大任务队列最大任务数
	int currentTaskSize() const; 	//当前任务数

private:
	void _benginScheduler();	//调度管理
	void _createThread();	//创建一个新的线程
	void _checkThreadQueue();	//检查线程运行情况，将空闲线程置于空闲线程队列中
	void _stopAllThread();	//停止加入新任务，执行完队列中的任务
	void _sleepIntrval(const int ms);	//调度间隔
	WKThreadTask* _getTask();	//取一个队首任务
	void _updateElasticInterval(); // 更新弹性的检查间隔，工作线程增多则间隔检查间隔减少，否则增加
	
private:
	std::thread* m_pollingThread = nullptr;
	std::deque<WKThreadTask*> m_taskQueue;
	std::queue<WKThread*> m_threadDoneQueue;
	std::queue<WKThread*> m_threadWaitQueue;
	std::atomic<bool> m_bStoped = true;
	std::atomic<int> m_threadDoneCount = 0;
	std::atomic<int> m_threadWaitCount = 0;
	std::atomic<int> m_taskCount = 0;
	int m_maxThreadSize = 0;
	int m_maxTaskSize = 30;
	std::atomic<bool> m_bExiting = false;
	std::condition_variable m_condition;
	std::mutex m_mutex;
	int m_lastWaitThreadcount = 0;
	int m_waitThreadCountGradient = 0;
	int m_sleepIntrval = 0;
	WKLocker m_threadQueueWKLocker;
};
KKT-i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现一个线程池
zpznba的博客
04-21 858
说明 本线程池使用了互斥锁、条件变量、函数指针等常用工具。 线程池的创建与执行 threadpool_create创建线程池时，首先分配线程池数组和任务队列数组的空间，然后调用pthread_create创建线程，此时任务队列为空。 这样新创建的线程由于任务队列为空，所以都阻塞了。必须等待任务队列中有任务才能取执行。这部分实现使用条件变量。 当用threadpool_add添加很多任务后，每...
threadpool:C ++线程池库
05-20
Maginatics线程池 ThreadPool是线程池模式的C ++实现，允许将任意任务排队以由专用工作线程池执行。 它是仅标头的库，并且需要带有对Boost.Thread接口的版本4的支持。 Nathan Rosenblum）最初是ThreadPool，他是Maginatics的 。 概述 ThreadPool实现了一个有界线程池，该线程池具有最小的核心池大小，并且可以为空闲线程配置可保持活动状态； 那些熟悉Java 会发现熟悉的接口和语义。 其核心是预先分配的工作线程池。 如果有空闲工人可用，或者可以分配新工人而又不超过限制，则立即执行新任务； 否则，将任务添加到FIFO队列以供以后执行。 维护一个或多个线程的固定核心池，超过此限制的空闲线程将在可配置的保持活动时间段后终止。 使用范例 ThreadPool构造函数采用minPoolSize ， maxPoolSize和keepAl
【c++】线程池的原理及实现
CaTianRi的博客
05-09 754
不知道各位是否有试过点进限时抽奖网站、抢票网站呢？你是否好奇过一个网站、游戏是如何实现数十万、百万用户一起进行访问呢？其实这类软件的背后的服务器总是离不开一个叫做线程池的设计，而这就是本文将讲解的内容，学习如何设计线程池，是每个后端程序猿的必修课之一。掌握如何编写一个高效、安全的线程池对一个后端程序员来讲就像是西方不能没有耶路撒冷，毕竟如果要开发一个高并发需求的程序，例如抢票网站，服务器速度更不上、或者出现了线程安全，到时候用户就要寄律师函了。主页C++github。
c++实现线程池
tonny的博客
09-05 2443
c++实现线程池
C++新特性实现高效线程池，程序性能瞬间提升！
Lion_Long的博客
02-14 2585
本文深入探讨了如何利用C++新特性实现高效线程池，提升程序性能。首先介绍了C++11和C++14中提供的新特性，如std::thread、std::future、std::function等，并解释了它们如何用于线程池的实现。然后详细介绍了线程池的设计原理和实现过程，包括任务队列的管理、线程的管理以及线程池的调度策略。通过充分利用C++新特性，使得线程池在高并发场景下表现出色，大大提升了程序的性能和响应速度。
线程池-通过C++实现
qq_50726065的博客
06-26 2343
用到少量C++11的新特性。 1 池技术 2 线程池 3 线程池组成 5 测试程序
C++ 实现线程池ThreadPool
最新发布
06-04
3. **C++实现线程池的关键技术**： - **线程库**：C++11及更高版本提供了标准线程库 `<thread>`，提供了创建、同步和管理线程的基本功能。 - **std::queue**：用于实现任务队列，提供FIFO（先进先出）的数据结构。...
C++实现线程池的简单方法示例
08-19
C++实现线程池的简单方法示例 以下是根据给定的文件信息生成的知识点： 1. 线程池的概念：线程池是指一个池子中包含多个线程，每个线程都可以执行不同的任务。线程池可以提高系统的并发性能，减少线程创建和销毁的...
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、后进先出、优先级代码示例 五、看看人家线程池...
C++之深入解析如何实现一个线程池
╰つ栺尖篴夢ゞ
05-01 2130
当进行并行的任务作业操作时，线程的建立与销毁的开销是，阻碍性能进步的关键，因此线程池，由此产生。使用多个线程，无限制循环等待队列，进行计算和操作。帮助快速降低和减少性能损耗。 线程池管理器：初始化和创建线程，启动和停止线程，调配任务；管理线程池 工作线程：线程池中等待并执行分配的任务 任务接口：添加任务的接口，以提供工作线程调度任务的执行。 任务队列：用于存放没有处理的任务，提供一种缓冲机制，同时具有调度功能，高优先级的任务放在队列前面
C++基础组件——线程池实现
jiaoooooo的博客
05-14 999
C++系列文章目录 1、C++设计模式——单例模式 文章目录C++系列文章目录1、[C++设计模式——单例模式](https://blog.csdn.net/jiaoooooo/article/details/124613764)前言一、线程池定义线程池解决什么问题二、C语言实现三、C++实现1.v1版本问题2.v2版本总结 前言 实现线程池，给出C语言版以及两个C++版的实现方法，解决了一些常见问题，总结了遇到的问题及解决方法。 一、线程池定义 池化技术，起到了建立缓冲区的作用：内存池、数据库连接池
C++线程池的一种实现
hsy12342611的专栏
01-01 1581
C++线程池的一种实现
C++线程池简单实现
weixin_66448649的博客
06-30 5062
线程池: 当进行并行的任务作业操作时，线程的建立与销毁的开销是，阻碍性能进步的关键，因此线程池，由此产生。使用多个线程，无限制循环等待队列，进行计算和操作。帮助快速降低和减少性能损耗。 线程池的主要组成有上面三个部分：..................
如何用C++实现线程池
09-13
### 回答1： 实现线程池的方法有很多，但是最常见的方法是使用队列来维护任务。每个线程都在队列中等待任务，当有新任务到达时，就从队列中取出一个任务并执行。这样，每个线程都可以在并行执行任务，而不需要创建新的线程。 在C语言中实现线程池的代码如下： ``` #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NUM_THREADS 5 void *print_hello(void *threadid) { long tid; tid = (long)threadid; printf("Hello World! It's me, thread #%ld!\n", tid); pthread_exit(NULL); } int main(int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; int rc; long t; for (t = 0; t < NUM_THREADS; t++) { printf("In main: creating thread %ld\n", t); rc = pthread_create(&threads[t], NULL, print_hello, (void *)t); if (rc) { printf("ERROR; return code from pthread_create() is %d\n", rc); exit(-1); } } pthread_exit(NULL); } ``` ### 回答2： 要实现线程池，首先需要先了解线程池的基本概念和原理。 线程池是一种用来管理和复用线程的技术，它能够维护一个线程队列，按需创建和销毁线程，并将任务分配给这些线程来执行。使用线程池可以提高程序的性能，减少线程创建和销毁的开销。 在C语言中，可以使用多线程的库来实现线程池，比如pthread库。下面是一个简单的用C语言实现线程池的步骤： 1. 定义线程池结构体：创建一个结构体来保存线程池的相关信息，如线程池的大小、任务队列、互斥锁、条件变量等。 2. 初始化线程池：在初始化函数中，需要对线程池中的各个成员进行初始化，如创建指定数量的线程、初始化互斥锁和条件变量等。 3. 定义任务函数：线程池的任务函数用于处理任务队列中的任务，根据具体需求来定义任务的执行逻辑。 4. 添加任务到线程池：当有新的任务时，将任务添加到任务队列中，并通过条件变量来通知线程池中的线程有新任务可执行。 5. 线程池中的线程获取任务并执行：在线程中循环检查任务队列，当有任务时，线程从任务队列中获取任务并执行。 6. 销毁线程池：在停止使用线程池时，要销毁线程池中的资源，包括线程的回收、互斥锁和条件变量的销毁等。 通过以上步骤，就可以在C语言中实现一个简单的线程池。具体实现中还需要考虑线程同步、任务队列的管理等问题，以确保线程池的稳定性和性能。 ### 回答3： 线程池是用来管理和复用线程的一种机制，可以更有效地使用系统资源和提高应用程序的性能。下面是使用C语言实现线程池的一般步骤： 1. 定义一个线程池的结构体，包含线程池的状态、大小、最大线程数、工作任务队列等信息。 ```c typedef struct { pthread_t *threads; // 线程数组 int thread_count; // 线程数 int max_threads; // 最大线程数 int pool_size; // 线程池大小 int shutdown; // 关闭标志 pthread_mutex_t mutex; // 互斥锁 pthread_cond_t notify; // 条件变量 Task *task_queue; // 任务队列 } ThreadPool; ``` 2. 初始化线程池，创建指定数量的线程。 ```c ThreadPool* thread_pool_init(int pool_size) { ThreadPool *pool = malloc(sizeof(ThreadPool)); pool->threads = malloc(pool_size * sizeof(pthread_t)); pool->thread_count = pool_size; pool->max_threads = pool_size; pool->pool_size = 0; pool->shutdown = 0; // 初始化互斥锁和条件变量 pthread_mutex_init(&(pool->mutex), NULL); pthread_cond_init(&(pool->notify), NULL); // 创建线程 for (int i = 0; i < pool_size; i++) { pthread_create(&(pool->threads[i]), NULL, thread_worker, (void*)pool); } return pool; } ``` 3. 定义线程工作函数，不断从任务队列中取出任务执行。 ```c void* thread_worker(void *arg) { ThreadPool *pool = (ThreadPool*)arg; while (1) { pthread_mutex_lock(&(pool->mutex)); // 线程池关闭，退出线程 while (pool->pool_size == 0 && !pool->shutdown) { pthread_cond_wait(&(pool->notify), &(pool->mutex)); } if (pool->shutdown) { pthread_mutex_unlock(&(pool->mutex)); pthread_exit(NULL); } // 从任务队列中取出任务执行 Task *task = pool->task_queue; pool->task_queue = pool->task_queue->next; pool->pool_size--; pthread_mutex_unlock(&(pool->mutex)); task->func(task->arg); free(task); } pthread_exit(NULL); } ``` 4. 定义任务结构体，包含任务函数指针和参数。 ```c typedef struct Task { void (*func)(void*); void *arg; struct Task *next; } Task; ``` 5. 向线程池中添加任务。 ```c void thread_pool_add_task(ThreadPool *pool, void (*func)(void*), void *arg) { Task *task = malloc(sizeof(Task)); task->func = func; task->arg = arg; task->next = NULL; pthread_mutex_lock(&(pool->mutex)); if (pool->task_queue == NULL) { pool->task_queue = task; } else { Task *cur = pool->task_queue; while (cur->next != NULL) { cur = cur->next; } cur->next = task; } pool->pool_size++; pthread_mutex_unlock(&(pool->mutex)); pthread_cond_signal(&(pool->notify)); } ``` 6. 关闭线程池。 ```c void thread_pool_shutdown(ThreadPool *pool) { if (pool == NULL) { return; } pthread_mutex_lock(&(pool->mutex)); pool->shutdown = 1; pthread_mutex_unlock(&(pool->mutex)); pthread_cond_broadcast(&(pool->notify)); // 等待线程退出 for (int i = 0; i < pool->thread_count; i++) { pthread_join(pool->threads[i], NULL); } // 释放资源 free(pool->threads); while (pool->task_queue != NULL) { Task *next = pool->task_queue->next; free(pool->task_queue); pool->task_queue = next; } pthread_mutex_destroy(&(pool->mutex)); pthread_cond_destroy(&(pool->notify)); free(pool); } ``` 以上是一个简单的线程池的实现，通过初始化线程池、添加任务、关闭线程池等操作，可以有效地管理和复用线程，提高应用程序的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值