C++线程池的创建与应用

最新推荐文章于 2024-06-24 08:49:53 发布
最新推荐文章于 2024-06-24 08:49:53 发布
阅读量965 收藏 14
点赞数 3
分类专栏： c++开发 MFC 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38880029/article/details/127471164
版权

目录

前言

一、线程池的设计原理

1.1 概念

1.2 优缺点

二、线程池的实现

2.1 业务流程图

2.2 类的介绍

2.3 类间关系图

2.4 类的实现

2.4.1 IThreadPool类

2.4.2 ITask类

2.4.3 CMyMutex类

2.4.4 CMyThreadList类

2.4.5 CMyThreadStack类

2.4.6 CMyTaskQueue类

2.4.7 CTaskThread类

2.4.8 CThreadPool类

三、测试

3.1 demo源码

3.2 demo演示结果

总结

前言

       曾经接触过一个边扫描边识别图像的小项目，对时间和计算机资源要求比较高，针对这种情况，运用了C++线程池来快速、批量处理图像。

一、线程池的设计原理

1.1 概念

        线程池是大量线程的集合，里存放了很多可复用的辅助线程，用于批量处理任务。线程池是一种生产者-消费者模式（通过一系列容器来解决生产者和消费者的强耦合问题），生产者把任务丢给线程池，线程池动态分配线程并处理任务。

1.2 优缺点

线程池的优点：

  1. 降低线程创建及销毁带来的资源消耗；
  2. 避免线程间互抢资源而导致阻塞现象；
  3. 提高线程的可管理性和稳定性；

线程池的缺点：

  1. 占用一定量的内存空间；
  2. CPU调度开销随着线程数量增加；
  3. 程序实现的复杂度变高；

二、线程池的实现

2.1 业务流程图

f48e80ef9c5240d0be367af525453095.png

 

2.2 类的介绍

名称 描述
IThreadPool线程池接口
ITask任务类接口
CMyMutex互斥类
CMyThreadList活动线程列表类
CMyThreadStack空闲线程堆栈类
CMyTaskQueue任务队列类
CTaskThread任务处理线程类
CThreadPool线程池管理类

2.3 类间关系图

f420f3b1e0ad4f6583f913dec577a801.png

2.4 类的实现

2.4.1 IThreadPool类

#pragma once
#include "TaskThread.h"


// Thread Pool Interface
class IThreadPool
{
public:
	virtual bool RecycleThread(CTaskThread *pTaskThread) = 0;

	virtual void SetDecodeResult(DWORD dwResult) = 0;
};

2.4.2 ITask类

#pragma once

// Task Interface
class ITask {
public:
	virtual unsigned long TaskProc() = 0;
};

2.4.3 CMyMutex类

#pragma once

#include <Windows.h>

class CMyMutex {
public:
	CMyMutex(void) {
		::InitializeCriticalSection(&m_csMutex);
	}
	virtual ~CMyMutex(void) {
		::DeleteCriticalSection(&m_csMutex);
	}

	bool Lock() {
		::EnterCriticalSection(&m_csMutex);
		return true;
	}

	bool Unlock() {
		::LeaveCriticalSection(&m_csMutex);
		return true;
	}

private:
	CRITICAL_SECTION m_csMutex;
};

2.4.4 CMyThreadList类

#pragma once
#include <list>
#include "MyMutex.h"
#include "TaskThread.h"

class CMyThreadList {
public:
	CMyThreadList(void) {}
	virtual ~CMyThreadList(void) {}

	bool Add(CTaskThread *pTaskThread) {
		m_mtxSync.Lock();
		bool bResult = false;
		if (pTaskThread) {
			m_lstTaskThread.push_back(pTaskThread);
			bResult = true;
		}
		m_mtxSync.Unlock();

		return bResult;
	}

	bool Remove(CTaskThread *pTaskThread) {
		m_mtxSync.Lock();
		bool bResult = false;
		if (!m_lstTaskThread.empty()) {
			m_lstTaskThread.remove(pTaskThread);
			bResult = true;
		}
		m_mtxSync.Unlock();

		return bResult;
	}

	int Size() {
		m_mtxSync.Lock();
		int nStackSize = m_lstTaskThread.size();
		m_mtxSync.Unlock();

		return nStackSize;
	}

	bool IsEmpty() {
		m_mtxSync.Lock();
		bool bEmpty = m_lstTaskThread.empty();
		m_mtxSync.Unlock();

		return bEmpty;
	}

	bool Clear() {
		m_mtxSync.Lock();
		while (!m_lstTaskThread.empty()) {
		}

		bool bEmpty = (0 == m_lstTaskThread.size());
		m_mtxSync.Unlock();

		return bEmpty;
	}

private:
	CMyMutex m_mtxSync;
	std::list<CTaskThread *> m_lstTaskThread;
};

2.4.5 CMyThreadStack类

#pragma once
#include <stack>
#include "MyMutex.h"
#include "TaskThread.h"

class CMyThreadStack
{
public:
	CMyThreadStack(void) {}
	virtual ~CMyThreadStack(void) {}

	CTaskThread *Pop() {
		m_mtxSync.Lock();
		CTaskThread *pTaskThread = NULL;
		if (!m_stkTaskThread.empty()) {
			pTaskThread = m_stkTaskThread.top();
			m_stkTaskThread.pop();
		}
		m_mtxSync.Unlock();

		return pTaskThread;
	}

	bool Push(CTaskThread *pTaskThread) {
		m_mtxSync.Lock();
		bool bResult = false;
		if (NULL != pTaskThread) {
			m_stkTaskThread.push(pTaskThread);
			bResult = true;
		}
		m_mtxSync.Unlock();

		return bResult;
	}

	int Size() {
		m_mtxSync.Lock();
		int nStackSize = m_stkTaskThread.size();
		m_mtxSync.Unlock();

		return nStackSize;
	}
	
	bool IsEmpty() {
		m_mtxSync.Lock();
		bool bEmpty = m_stkTaskThread.empty();
		m_mtxSync.Unlock();

		return bEmpty;
	}

	bool Clear() {
		m_mtxSync.Lock();
		while (!m_stkTaskThread.empty()) {
			CTaskThread *pTaskThread = m_stkTaskThread.top();
			m_stkTaskThread.pop();

			pTaskThread->SuspendThread();

			delete pTaskThread;
		}

		bool bEmpty = (0 == m_stkTaskThread.size());
		m_mtxSync.Unlock();

		return bEmpty;
	}

private:
	CMyMutex m_mtxSync;
	std::stack<CTaskThread *> m_stkTaskThread;
};

2.4.6 CMyTaskQueue类

#pragma once
#include <queue>
#include "ITask.h"
#include "MyMutex.h"

class CMyTaskQueue {
public:
	CMyTaskQueue(void) {}
	virtual ~CMyTaskQueue(void) {}

	ITask *Pop() {
		m_mtxSync.Lock();
		ITask *pMyTask = NULL;
		if (!m_queMyTask.empty()) {
			pMyTask = m_queMyTask.front();
			m_queMyTask.pop_front();
		}
		m_mtxSync.Lock();

		return pMyTask;
	}

	bool PushFront(ITask *pMyTask) {
		m_mtxSync.Lock();
		bool bResult = false;
		if (pMyTask) {
			m_queMyTask.push_front(pMyTask);
			bResult = true;
		}
		m_mtxSync.Unlock();

		return bResult;
	}

	bool PushBack(ITask *pMyTask) {
		m_mtxSync.Lock();
		bool bResult = false;
		if (pMyTask) {
			m_queMyTask.push_back(pMyTask);
			bResult = true;
		}
		m_mtxSync.Unlock();

		return bResult;
	}

	int Size() {
		m_mtxSync.Lock();
		int nStackSize = m_queMyTask.size();
		m_mtxSync.Unlock();

		return nStackSize;
	}

	bool IsEmpty() {
		m_mtxSync.Lock();
		bool bEmpty = m_queMyTask.empty();
		m_mtxSync.Unlock();

		return bEmpty;
	}

	bool Clear() {
		m_mtxSync.Lock();
		while (!m_queMyTask.empty()) {
		}

		bool bEmpty = (0 == m_queMyTask.size());
		m_mtxSync.Unlock();

		return bEmpty;
	}

private:
	CMyMutex m_mtxSync;
	std::deque<ITask *> m_queMyTask;
};

2.4.7 CTaskThread类

头文件

#pragma once
#include <Windows.h>

class ITask;
class IThreadPool;

class CTaskThread
{
public:
	CTaskThread(IThreadPool *pIThreadPool);
	virtual ~CTaskThread(void);

	// Create & start a thread
	bool StartThread();

	// Startup the thread
	bool ResumeThread();

	// Stop the thread
	bool SuspendThread();

	// Assign a task to this thread
	bool AssignTask(ITask *pMyTask);

	// Thread default handler
	static DWORD WINAPI ThreadProc(LPVOID lParam);

private:
	BOOL	m_bExitThread;
	DWORD	m_dwThreadID;
	HANDLE	m_hThread;
	HANDLE	m_hEvent;

	ITask		*m_pMyTask;
	IThreadPool	*m_pIThreadPool;
};

 源文件

#include "TaskThread.h"
#include "ThreadPool.h"


CTaskThread::CTaskThread(IThreadPool *pIThreadPool)
{
	m_bExitThread = FALSE;
	m_hThread = NULL;
	m_hEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
	m_pMyTask = NULL;
	m_pIThreadPool = pIThreadPool;
}

CTaskThread::~CTaskThread(void)
{
	m_bExitThread = TRUE;

	if (m_hThread) {
		DWORD dwResult = ::WaitForSingleObject(m_hThread, 100);
		if (WAIT_OBJECT_0 != dwResult) {
			TerminateThread(m_hThread, 0);
		}
		CloseHandle(m_hThread);
		m_hThread = NULL;
	}

	if (m_hEvent) {
		CloseHandle(m_hEvent);
		m_hEvent = NULL;
	}
}

bool CTaskThread::StartThread()
{
	if (!m_hThread) {
		m_hThread = ::CreateThread(NULL, 0, ThreadProc, this, 0, &m_dwThreadID);
		if (INVALID_HANDLE_VALUE == m_hThread) {
			return false;
		}

		printf("New a thread: %d\n", m_dwThreadID);
	}
	
	return true;
}

bool CTaskThread::ResumeThread()
{
	::SetEvent(m_hEvent);
	m_bExitThread = FALSE;

	return true;
}

bool CTaskThread::SuspendThread()
{
	::ResetEvent(m_hEvent);
	m_bExitThread = TRUE;
	
	return true;
}

bool CTaskThread::AssignTask(ITask *pMyTask)
{
	if (!pMyTask) return false;

	m_pMyTask = pMyTask;

	return true;
}

DWORD WINAPI CTaskThread::ThreadProc(LPVOID lParam)
{
	CTaskThread *pThis = (CTaskThread*)lParam;

	while (!pThis->m_bExitThread) {
		DWORD dwResult = ::WaitForSingleObject(pThis->m_hEvent, INFINITE);
		if (WAIT_OBJECT_0 == dwResult) {
			if (pThis->m_pMyTask) {
				printf("Current thread: %d, Current task: %d\n", (int)pThis->m_dwThreadID, (int)pThis->m_pMyTask);

				// Task is valid
				DWORD dwResult = pThis->m_pMyTask->TaskProc();

				pThis->m_pIThreadPool->SetDecodeResult(dwResult);

				delete pThis->m_pMyTask;
				pThis->m_pMyTask = NULL;

				// Recycle this thread
				pThis->m_pIThreadPool->RecycleThread(pThis);
			}
		}
	}

	return 0;
}

2.4.8 CThreadPool类

头文件

#pragma once
#include "ITask.h"
#include "IThreadPool.h"
#include "MyThreadStack.h"
#include "MyThreadList.h"
#include "MyTaskQueue.h"

typedef void(*DecodeResult)(char *pResultBuf, unsigned int unResultBufSize);


enum EUM_PRIORITY
{
	NORMAL,
	HIGH
};

class CThreadPool : public IThreadPool
{

public:
	// Use singleton mode to create objects
	static CThreadPool* GetInstance(void);

	// Default destructor
	virtual ~CThreadPool(void);

	// Push an idle thread into stack
	virtual bool PushIdleThread(CTaskThread *pTaskThread);

	// Pop an idle thread from stack
	virtual CTaskThread* PopIdleThread();

	virtual bool RecycleThread(CTaskThread *pTaskThread);

	// Assign a task
	virtual bool SetTask(ITask *pMyTask, EUM_PRIORITY eumPriority= NORMAL);

	// Get a task
	virtual ITask* GetTask();

	// Set callback function
	bool SetCallbackFun(void *pCallback);

	// Get the result of image decoding
	void SetDecodeResult(DWORD dwResult);

private:
	// Default constructor
	CThreadPool(void);

	// Perform initialization
	bool _Initialize(int nThreadAmount);

	// Perform cleanup
	void _Cleanup();

	// Dynamically allocate threads
	bool _ReallocateThreads();

	DecodeResult m_fDecodeResult;

private:
	int m_nThreadActiveLow;
	int m_nThreadActiveHigh;
	int m_nThreadTotal;
	int m_nCpuCoreTotal;

	CMyMutex		*m_pMyMutex;
	CMyTaskQueue	*m_pTaskQueue;
	CMyThreadStack	*m_pIdleThreadStack;
	CMyThreadList	*m_pActiveThreadList;
};

源文件

#include "ThreadPool.h"
#include "TaskThread.h"
#include <cassert>
#include<stdlib.h>


CThreadPool* CThreadPool::GetInstance(void)
{
	static CThreadPool* pNewThreadPool = NULL;
	if (NULL == pNewThreadPool) {
		pNewThreadPool = new CThreadPool();
		assert(pNewThreadPool);
	}

	return pNewThreadPool;
}

CThreadPool::CThreadPool(void)
{
	m_pMyMutex = NULL;
	m_pTaskQueue = NULL;
	m_pIdleThreadStack = NULL;
	m_pActiveThreadList = NULL;
	m_fDecodeResult = NULL;

	SYSTEM_INFO SysemInfo;
	GetSystemInfo(&SysemInfo);
	int nCpuCount = SysemInfo.dwNumberOfProcessors;

	nCpuCount = 4;

	m_nThreadActiveLow = 4;
	m_nThreadActiveHigh = 10;
	m_nThreadTotal = 10;
	m_nCpuCoreTotal = nCpuCount;

	
	// Initialize thread pool
	_Initialize(m_nThreadTotal);
}

CThreadPool::~CThreadPool(void)
{
	// Clearup thread pool
	_Cleanup();
}

bool CThreadPool::PushIdleThread(CTaskThread *pTaskThread)
{
	bool bResult = false;
	if (m_pIdleThreadStack) {
		m_pIdleThreadStack->Push(pTaskThread);
		bResult = true;
	}

	return bResult;
}

CTaskThread* CThreadPool::PopIdleThread()
{
	CTaskThread *pTaskThread = NULL;
	if (!m_pIdleThreadStack->IsEmpty()) {
		pTaskThread = m_pIdleThreadStack->Pop();
	}

	return pTaskThread;
}

bool CThreadPool::RecycleThread(CTaskThread *pTaskThread)
{
	if (!m_pTaskQueue->IsEmpty()) {
		ITask *pCurTask = m_pTaskQueue->Pop();
		if (pCurTask && pTaskThread) {
			pTaskThread->AssignTask(pCurTask);
			pTaskThread->ResumeThread();
		}

		// Dynamically allocate threads
		_ReallocateThreads();
	}
	else {
		m_pActiveThreadList->Remove(pTaskThread);
		m_pIdleThreadStack->Push(pTaskThread);
	}

	return true;
}

bool CThreadPool::SetTask(ITask *pMyTask, EUM_PRIORITY eumPriority)
{
	if (HIGH == eumPriority) {
		m_pTaskQueue->PushFront(pMyTask);
	}
	else {
		m_pTaskQueue->PushBack(pMyTask);
	}

	if (!m_pTaskQueue->IsEmpty()) {
		ITask *pCurTask = m_pTaskQueue->Pop();
		CTaskThread *pTaskThread = m_pIdleThreadStack->Pop();

		if (pCurTask && pTaskThread) {
			pTaskThread->AssignTask(pCurTask);
			pTaskThread->ResumeThread();

			// Dynamically allocate threads
			_ReallocateThreads();

			return true;
		}
	}

	return false;
}

ITask* CThreadPool::GetTask()
{
	ITask *pMyTask = NULL;
	if (!m_pTaskQueue->IsEmpty()) {
		pMyTask = m_pTaskQueue->Pop();
	}

	return pMyTask;
}

bool CThreadPool::_Initialize(int nThreadAmount)
{
	if (!m_pMyMutex) m_pMyMutex = new CMyMutex();
	if (!m_pTaskQueue) m_pTaskQueue = new CMyTaskQueue();
	if (!m_pIdleThreadStack) m_pIdleThreadStack = new CMyThreadStack();
	if (!m_pActiveThreadList) m_pActiveThreadList = new CMyThreadList();

	assert(m_pMyMutex && m_pTaskQueue && m_pIdleThreadStack && m_pActiveThreadList);

	for (int i = 0; i<nThreadAmount; i++) {
		CTaskThread *pMyThread = new CTaskThread(this);
		assert(pMyThread);

		PushIdleThread(pMyThread);
		pMyThread->StartThread();
	}

	return true;
}

void CThreadPool::_Cleanup()
{
	if (m_pMyMutex) {
		delete m_pMyMutex;
		m_pMyMutex = NULL;
	}

	if (m_pTaskQueue) {
		m_pTaskQueue->Clear();
		delete m_pTaskQueue;
		m_pTaskQueue = NULL;
	}

	if (m_pIdleThreadStack) {
		m_pIdleThreadStack->Clear();
		delete m_pIdleThreadStack;
		m_pIdleThreadStack = NULL;
	}

	if (m_pActiveThreadList) {
		m_pActiveThreadList->Clear();
		delete m_pActiveThreadList;
		m_pActiveThreadList = NULL;
	}
}

bool CThreadPool::_ReallocateThreads()
{
	m_pMyMutex->Lock();
	int nActiveThread = m_nThreadTotal - m_pIdleThreadStack->Size();
	if (m_nThreadActiveLow >= nActiveThread && m_nThreadActiveHigh >= m_nThreadTotal) {
		// If the number of active threads is insufficient and the total number of threads don't exceed the limit, the threads will be allocated again
		_Initialize(m_nCpuCoreTotal);
		m_nThreadTotal += m_nCpuCoreTotal;
	}

	m_pMyMutex->Unlock();

	return true;
}

bool CThreadPool::SetCallbackFun(void *pCallback)
{
	if (pCallback) {
		m_fDecodeResult = (DecodeResult)pCallback;
		return true;
	}
	else {
		return false;
	}
}

void CThreadPool::SetDecodeResult(DWORD dwResult)
{
	char szResult[10] = { 0 };
	_ltoa_s(dwResult, szResult, 10);

	m_fDecodeResult(szResult, strlen(szResult));
}

三、测试

3.1 demo源码

main.cpp

#include <stdio.h>

// add necessary includes here
#include "../ThreadPool/ImageProcess.h"
#include <iostream>   
using   namespace   std;

#ifdef _DEBUG
#pragma comment(lib, "../Debug/ThreadPool.lib")
#else
#pragma comment(lib, "../Release/ThreadPool.lib")
#endif

void myDecodeResult(char *pResultBuf, unsigned int unResultBufSize)
{
	printf("myDecodeResult() barcode=%s\n", pResultBuf);
}

int main(void)
{
	char szPath[260] = "E:\\images\\";

	FeedbackResult(myDecodeResult);

	for (int i = 0; i < 20; i++) {
		PushImages(szPath, sizeof(szPath));
		_sleep(100);
	}
	
	//printf("fnPushImage() %d %s\n", nResult, szPath);

	getchar();
	return 0;
}

3.2 demo演示结果

New a thread: 21100
New a thread: 28040
New a thread: 11524
New a thread: 16328
New a thread: 10252
New a thread: 26128
New a thread: 24076
New a thread: 22124
New a thread: 25088
New a thread: 7236
Current thread: 7236, Current task: 14971584
New a thread: 17012
New a thread: 17208
New a thread: 9744
New a thread: 27136
Current thread: 27136, Current task: 14970864
Current thread: 9744, Current task: 14971056
Current thread: 17208, Current task: 14970912
Current thread: 17012, Current task: 14970960
Current task: 14971584, Rand result: 542441015
myDecodeResult() barcode=542441015
Current thread: 25088, Current task: 14971200
Current task: 14970864, Rand result: 542441140
myDecodeResult() barcode=542441140
Current thread: 22124, Current task: 14971584
Current task: 14971056, Rand result: 542441250
myDecodeResult() barcode=542441250
Current thread: 24076, Current task: 14971008
Current task: 14970912, Rand result: 542441359
myDecodeResult() barcode=542441359
Current thread: 26128, Current task: 14970864
Current task: 14970960, Rand result: 542441453
myDecodeResult() barcode=542441453
Current thread: 10252, Current task: 14970960
Current task: 14971200, Rand result: 542441562
myDecodeResult() barcode=542441562
Current thread: 16328, Current task: 14971392
Current task: 14971584, Rand result: 542441671
myDecodeResult() barcode=542441671
Current thread: 11524, Current task: 14971296
Current task: 14971008, Rand result: 542441781
myDecodeResult() barcode=542441781
Current thread: 28040, Current task: 14971584
Current task: 14970864, Rand result: 542441890
myDecodeResult() barcode=542441890
Current thread: 21100, Current task: 14971104
Current task: 14970960, Rand result: 542442000
myDecodeResult() barcode=542442000
Current task: 14971392, Rand result: 542442109
myDecodeResult() barcode=542442109
Current task: 14971296, Rand result: 542442218
myDecodeResult() barcode=542442218
Current task: 14971584, Rand result: 542442328
myDecodeResult() barcode=542442328
Current task: 14971104, Rand result: 542442437
myDecodeResult() barcode=542442437

总结

       线程池使用可以在一定程序提高程序处理性能，如果使用不当，可能会造成死锁，且很难定位到错误点，应当谨慎使用。

 

北星之茫
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线程池原理及创建（C++实现）
08-27
线程池原理及创建（C++实现）线程池原理及创建（C++实现）线程池原理及创建（C++实现）线程池原理及创建（C++实现）
线程池原理及创建(C++实现)
04-08
线程池原理及创建(C++实现)；学习线程池等池类工具的参考资料，比较浅显易懂。网上收集，供交流学习。
九、Linux系统编程：线程池编程
小脑斧的博客
05-26 221
线程池编程
C++14 线程池通用基础用法
最新发布
weixin_42318094的博客
06-24 199
c++14通用基础线程池的用法记录
C++实现线程池
923723914
06-04 409
C++实现线程池。 欢迎转载，转载请注明原出处：http://blog.csdn.net/ithzhang/article/details/9020283 代码地址：https://github.com/ithzhang/ThreadpoolLib.git 本文介绍的线程池采用C++语言，在windows平台下实现。此版本为Version1.0，以后还...
C++实现线程池详解
威桑的博客
06-03 892
Windows 下 C++ 实现线程池
c++ 线程池实现，应用并发处理
01-01
在C++编程中，线程池是一种有效地管理并发任务的技术，它可以提高系统资源的利用率，减少线程创建和销毁的开销。...开发者可以通过这个实例学习如何在C++中高效地实现线程池，以支持应用程序的多线程并发处理。
线程池原理及创建（C++实现
01-27
线程池原理及创建（C++实现） 本文将详细介绍线程池的原理和创建过程，并提供一个通用的线程池框架，具有动态伸缩性，可以根据执行任务的轻重自动调整线程池中线程的数量。 线程池的必要性 在高并发的服务器环境...
c++ 线程池工具thread_pool
01-05
C++线程池工具，通常被称为`thread_pool`，是一种高效地管理多个并发线程的机制，它在多线程编程中扮演着重要的角色。线程池通过预先创建一组线程，然后根据需要分配任务，避免了频繁创建和销毁线程的开销，从而提升...
企业级跨平台C++线程池实现
12-27
在企业级软件开发中，跨平台的C++线程池是一种高效、可靠的任务调度机制，它允许多个任务并行执行，充分利用多核处理器的计算能力。线程池的实现通常涉及多线程编程，线程同步，以及任务管理等核心概念。下面将详细...
c++ 线程池
01-10
下面是一个简单的C++线程池实现示例： ```cpp #include #include #include #include #include class ThreadPool { public: ThreadPool(size_t numThreads) : stopped(false) { for (size_t i = 0; i ; ++i)...
[C++][线程池][完整实现] 转：线程池原理及创建（C++实现）
热门推荐
yfcheng_yzc的专栏
01-09 1万+
文章的主要框架是参考这篇文档的，http://jacky-dai.iteye.com/blog/1090285, 关于作者  张中庆，西安交通大学软件所，在读硕士，目前研究方向为分布式网络与移动中间件，对Linux极其爱好，可以通过flydish1234@sina.com.cn与我联系 其实看了好多类似的，都是没有完整的实现，自己花了点时间把这个程序梳理了一下，写了个测试程序，目前可以跑通。
使用c++11创建自己的线程池
wanghualin033的博客
07-22 575
    以前一直使用Qt的线程池，在Qt应用中还是很方便，Qt自带的线程池，每一个任务QRunable的run函数执行完后，线程会退出，有些时候是不需要退出的，这里可以在run函数中做一些操作；这里我用c++11写了一个自己的线程池。      主要是用一个线程安全的队列、std::thread、容器实现的。首先我实现的队列如下。  #ifndef CONCURRENTQUEUE_H #de...
C++实现一个线程池
weixin_45131842的博客
04-23 122
使用C++写一个最简单的线程池
使用C++实现一个简单的线程池
Huoon的博客
04-14 2830
线程池类似于内存池，连接池等，在一开始创建好一定数量的线程，当有任务需要处理时，就将该任务丢进线程池的某个线程中处理，而不是每个任务都启动一个线程。使用线程池的好处在于，不需要频繁的创建线程，因为创建线程是一个较耗资源的操作。因此，相对而言一开始创建好线程，要比动态创建线程对性能影响更小。其次，线程池可以更好的将线程管理起来，对外提供简单的接口，内部完成对线程的调度，这也是高内聚的一个思想，将复杂封装起来，对外在满足业务场景的前提下尽可能简单。线程池作为一个独立的非业务模块，任何需要处理多任务的场景都可以使
【C++】使用C++ 11新特性创建线程池
Cain Xcy的博客
08-29 3742
01、目录 目录01、目录02、线程池03、线程池示例3.1 示例一（常规实现）3.2 示例2 （适用于需传参，需要将非静态线程函数写在类中的情况）04、emplace_back的示例和异常05、小结 02、线程池 顾名思义，线程池就是容纳n个（n>=2）线程的池子（pool），这是字面意思。 线程池：因为程序边运行边创建线程是比较耗时的，所以我们通过池化的思想，在程序开始运行前创建多个线程，这样，程序在运行时，只需要从线程池中拿来用就可以了．大大提高了程序运行效率． 没错，线程池的存在就是为了程
c++线程池
06-01
C++线程池可以用来处理一些需要并发执行的任务，同时避免频繁创建和销毁线程所带来的开销。下面是一个简单的C++线程池实现： ```cpp #include <iostream> #include <queue> #include <thread> #include <mutex> #include <condition_variable> class ThreadPool { public: ThreadPool(size_t num_threads) { for (size_t i = 0; i < num_threads; ++i) { threads_.emplace_back([this] { while (true) { Task task; { std::unique_lock<std::mutex> lock(mutex_); cond_.wait(lock, [this] { return !tasks_.empty() || stop_; }); if (stop_ && tasks_.empty()) return; task = std::move(tasks_.front()); tasks_.pop(); } task(); } }); } } ~ThreadPool() { { std::unique_lock<std::mutex> lock(mutex_); stop_ = true; } cond_.notify_all(); for (auto& thread : threads_) { thread.join(); } } template <typename Func, typename... Args> void AddTask(Func&& func, Args&&... args) { auto task = std::bind(std::forward<Func>(func), std::forward<Args>(args)...); { std::unique_lock<std::mutex> lock(mutex_); tasks_.emplace(std::move(task)); } cond_.notify_one(); } private: using Task = std::function<void()>; std::vector<std::thread> threads_; std::queue<Task> tasks_; std::mutex mutex_; std::condition_variable cond_; bool stop_ = false; }; ``` 这个实现定义了一个ThreadPool类，构造函数中创建了指定数量的线程，并且每个线程都会从任务队列中获取任务并执行；析构函数中会通知所有线程停止执行，并等待所有线程退出；AddTask方法用于添加一个任务到任务队列中。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值