c++实现线程池（真实入门！）

最新推荐文章于 2024-08-03 12:53:54 发布
最新推荐文章于 2024-08-03 12:53:54 发布
阅读量7.1k 收藏 127
点赞数 26
分类专栏： c++ 操作系统 文章标签： C++ 多线程 线程池 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kprogram/article/details/89437073
版权

10分钟学会用C++编写一个简单的线程池（使用windows.h头文件）

前言

这是我们操作系统专业课的一次编程作业，作为菜鸡的我搜索了大量的线程池博客，但不是代 码太秀，比较难懂，就是实现的线程池功能太过强大，不适合入门，或是讲解重点并没解决我 的问题，而不同博客使用的头文件又不同；很难有只需一篇就能让菜鸡搞懂的博客。

所以我打算以我从零开始理解的角度完成这篇 实验报告 博客，能让最菜的菜鸡也能看懂并手 动实现一个最简单的线程池。

但要做到这一点，需要有一点点前提条件：

  1. 只需要有简单的c++面向对象编程的能力。
  2. 会使用win自带的 “windows.h” 头文件进行多线程编程。
  3. 对线程有基本的理解。

而我们最终能得到的线程池拥有的功能有：

  1. 实现线程池最基本的功能能：线程重复利用，少量线程完成大量工作（线程数<任务 数）。
  2. 可自己设计任务函数，而不是简单的模拟。（同GreatThread() 传入参数的方法类似）
  3. 可调节线程池的线程数，空闲线程等待时间等。
  4. 可随时添加新任务，添加结束后可调用等待函数等待线程完成所有工作。
  5. 不能直接接收返回值，但返回值可利用传入的参数指针传回。

基本概念

  1. 为啥要有线程池
    一般的多线程编程，往往是一个线程对应一个 ‘任务’ 。但由于线程的建立于销毁也会造成一部分开销，所以当任务过多的时候，若还是一个任务对应一个线程，线程的反复建立与销毁，会造成大量的的资源浪费。

  2. 什么是任务
    这一点是大部分博客都没有提及的，以我的理解，这里的任务所指的是你打算在线程函数里面完成的工作，比如打印 “hello word” 或者做一些计算之类的。
    而大部分任务往往都能封装进一个函数，所以这里的任务往往就是指一个有明确目的函数（相同函数传入不同参数也能看成不同的任务）

  3. 什么是线程池
    如果我们重复利用几个线程，去完成比线程数更多的任务，那不就避免了线程建立和销毁造成的开销么。
    一句话说：线程池就是一种利用少量线程解决大量任务（线程数 < 任务数）的工具。
    而高级的线程池会从线程的数量，线程的活跃时间，任务的存取策略等角度进行优化，以达到更高效目的。

  4. 如何实现
    我们可以把所有的任务放在一个队列内，并创建一定数量的线程。线程空闲时，可以自动从任务队列中取出任务，任务完成后，又进入空闲，并尝试取出下一个任务。而这，就是最简单的线程池了。

代码实现

“任务”的封装

综上所述，我们需要实现的任务需要有这样的特性：

  1. 创建任务和运行任务可以不同步（不同于简单的调用函数）。
  2. 因为要放入队列，所以需要有具体的数据结构。
  3. 需要固定任务的格式（总不能让用户随便传入啥类型的函数都行吧，得规范一下）

解决方案：

首先，统一任务函数的格式：”参数为 void 指针，返回值为void（没有返回值）“。

这样的话，利用void指针可以指向任何数据的特性，任务函数可以传入任意类型的参数了，也可以利用指针传回返回值。

// 声明fp_return_void类型
typedef void(*fp_return_void)(void *paramter);

见：函数指针的用法

其次，将函数指针和参数指针分开来， 并进行封装，想运行函数的时候，直接调用函数指针并把参数传入即可（见run()成员函数）

class Task
{
private:
	// 函数指针和参数指针
	fp_return_void fp;
	void *paramter;

	// 构造函数，需传入函数指针和参数指针
	Task(fp_return_void fp, void *param) :
		fp(fp), paramter(param) {}

	// 运行任务
	void run()
	{
		fp(paramter);
	}

public:// 声明为线程池的友元类
	friend class KyThreadPool;

};

Task使用方法：

// 声明自己的任务函数
void FuncName(void *lpParamter)
{
	int *pmd = (int *)lpParamter;// 假设需要传入int指针，(int *)表示强制类型转换，相当于告诉函数void指针指向的是int类型。
	cout << "task " << pmd[0] << " is working!\n";
}

//声明参数
int x = 1;
int *p = &x;

// 声明一个任务
Task onetask(FuncName, p); 
onetask.run(); // 运行任务

线程池框架构建

根据线程池的概念，线程池的主体必要两个东西：

  1. 线程函数，有任务的时候做任务，没任务的时候等任务，等久了就自动结束。
  2. 任务队列，用于存放任务，供线程函数提取任务用。（见：STL队列用法）

还需要一些池子的参数：

  1. 核心线程数/最大线程数（为了简便，假设核心线程数 = 最大线程数）
  2. 空闲线程等待时间，空闲线程也会占用cpu，所以不能让空闲线程活太久
  3. 现存线程数量，活跃线程数量，线程结束标志等，用于管理线程

以及几个供给用户使用的函数：

  1. 等待线程池函数，线程停止接收任务，等待剩余线程完成任务。
  2. 重启线程池函数，使线程池重新工作
  3. 添加任务函数，用于增加一个任务到队列中。

#define CORETHREADNUM 8
#define ALIVETIME 5000

// 线程池，任务默认先进先工作
class KyThreadPool
{
private:
	// 线程队列
	queue<Task> task_queue;

	// 线程函数（必须声明为静态数，才能作为参数传入GreatThread）
	static DWORD WINAPI SingleThread(LPVOID lpParamter);

	// 添加一个线程
	void AddOneThread();
	
	// 线程池信息
	int CoreThreadNum = CORETHREADNUM; // 核心线程数
	int NowThreadNum = 0;              // 现存线程数
	int ThreadEndFlag = 0;             // 线程立即结束标志
	int AliveTime = ALIVETIME;         // 空闲线程等待时间(单位：ms）

	// 互斥锁
	HANDLE TaskQueue_mutex;            // 任务队列读取锁
	HANDLE NowThreadNum_mutex;         // 线程数量修改锁
    HANDLE ActiveThreadNum_mutex;      // 活跃线程数修改锁
    
public:
    // 无参数构造函数，
	KyThreadPool()
	{
	    // 初始化锁
		task_queue_mutex = CreateMutex(NULL, FALSE, NULL);
		now_thread_num_mutex = CreateMutex(NULL, FALSE, NULL);
	}

	// 带参数构造函数，可设置线程信息（线程数，空闲线程生命长度)
	KyThreadPool(int CoreThreadNum, int AliveTime)
	{
		this->CoreThreadNum = CoreThreadNum;
		this->AliveTime = AliveTime;
		// 初始化锁
		task_queue_mutex = CreateMutex(NULL, FALSE, NULL);
		now_thread_num_mutex = CreateMutex(NULL, FALSE, NULL);
	}

    // 添加一个任务到任务队列，参数1：函数指针，参数2：函数参数
	void AddTask(fp_return_void function, void *arg);
	
	// 等待线程结束，使用后队列内添加的新任务不会再执行了
	void WaitAndEnd(void);
	
	// 池子重启，开启线程，执行队列内的任务。
	void PoolRestart(void);
};

成员函数实现

  1. 线程相关函数：SingleThread()， AddOneThread()

核心算法：让其一直循环判定任务队列是否为空，不为空则提取一个任务来完成就行了。

与池子的链接：直接把this指针当作参数传入线程函数即可，这样池子的任务队列以及各种参数就可供其使用了。

线程结束的判断：完成任务后，每次循环会计算其空闲的时间间隔，间隔超过ActiveTime或者接收到退出信息（ThreadEndFlag == 1）就会直接退出。

其它：注意线程状态更改时，对池子的相关参数也进行更改（线程数，活跃线程数等），也要注意共享资源加锁。

//线程函数本身
DWORD WINAPI KyThreadPool::SingleThread(LPVOID lpParamter)
{
	// 记录开始等待的时间
	DWORD wait_start_time = GetTickCount();
	// 这里lpParamter是传入的线程池的this指针，所以需要转换一下
	KyThreadPool *pool = (KyThreadPool*)lpParamter;

	while (1) // 循环等待任务
	{
		if (!pool->task_queue.empty() && pool->ThreadEndFlag == 0)// 如果有正在等待任务
		{
			WaitForSingleObject(pool->TaskQueue_mutex, INFINITE);// 加队列访问锁

			if (!pool->task_queue.empty()) {// 由于不知道.empty()函数是否具有原子性，所以加锁后再判断一遍

				// 取出任务，活跃线程数量+1
				Task T = pool->task_queue.front(); 
				pool->task_queue.pop();
				pool->ActiveThreadNum++;

				// 先解队列锁
				ReleaseMutex(pool->TaskQueue_mutex);

				//再执行任务
				T.run();

				// 记录新的等待开始的时间
				wait_start_time = GetTickCount();

				//活跃线程数量-1
				WaitForSingleObject(pool->ActiveThreadNum_mutex, INFINITE);
				pool->ActiveThreadNum--;
				ReleaseMutex(pool->ActiveThreadNum_mutex);
			}
			// 解队列锁
			else ReleaseMutex(pool->TaskQueue_mutex);
		}

		// 如果等待时间大于ActiveTime，或受到结束信息，则退出死循环，结束线程
		else if (pool->ThreadEndFlag == 1 || GetTickCount() - wait_start_time > pool->AliveTime)
		{
			// 减少一个现存线程数量
			WaitForSingleObject(pool->NowThreadNum_mutex, INFINITE);
			pool->NowThreadNum--;
			ReleaseMutex(pool->NowThreadNum_mutex);

			return 0L;
		}
	}
	return 0L;
}

//增加一个线程，注意细节：传入线程函数的参数是this指针
void KyThreadPool::AddOneThread()
{
	// 新增一个线程
	HANDLE hThread = CreateThread(NULL, 0, SingleThread, this, 0, NULL);

	// 增加一个现存线程数量
	WaitForSingleObject(NowThreadNum_mutex, INFINITE);
	NowThreadNum++;
	ReleaseMutex(NowThreadNum_mutex);
}
  1. 增加一个任务 ：AddTask()
// 传入参数：任务函数名（函数指针），任务函数参数
void KyThreadPool::AddTask(fp_return_void function, void *arg)
{

	WaitForSingleObject(TaskQueue_mutex, INFINITE);

	Task task(function, arg);
	this->task_queue.push(task);

	ReleaseMutex(TaskQueue_mutex);

	if (task_queue.size() > 0 && NowThreadNum < CoreThreadNum)
	{
		AddOneThread();
	}
}
  1. 等待以及重启函数：WaitAndEnd()，PoolRestart()
void KyThreadPool::WaitAndEnd(void)
{
    // 等待线程完成队列内的所有任务
	while (ActiveThreadNum > 0 || !task_queue.empty());
	ThreadEndFlag = 1;// 线程结束标记置为1（让线程直接退出等待状态）
}

void KyThreadPool::PoolRestart(void)
{
	// 线程结束标记置为0
	ThreadEndFlag = 0;
	// 建立等于当前任务数量的线程
	for (int i = 0; i < task_queue.size() && i < CoreThreadNum; i++)
	{
		AddOneThread();
	}
}

测试

  1. 任务函数：接收int指针，并打印任务信息（记得给打印设置互斥量）
void TestTask(void *lpParamter)
{
	int *pmd = (int *)lpParamter;// 接收整数参数
	WaitForSingleObject(cout_mutex, INFINITE);
	cout << "Task " << to_string(pmd[0]) << " is working!\n";
	ReleaseMutex(cout_mutex);

	Sleep(1000);// 工作一秒

	WaitForSingleObject(cout_mutex, INFINITE);
	cout << "Task " << to_string(pmd[0]) << " finished!\n";
	ReleaseMutex(cout_mutex);
}
  1. 测试函数：先装载15个任务， 等待后，重启，再装载15个任务（记得最后还得等待）
void KyThreadPoll_test(void)
{
	KyThreadPool PoolTest;
	int a[40];
	for (int i = 0; i < 15; i++)
	{
		a[i] = i;
		PoolTest.AddTask(TestTask, a + i);
	}

	PoolTest.WaitAndEnd();
	cout << "-------------------all Tasks finished!\n";
	PoolTest.PoolRestart();

	for (int i = 15; i < 30; i++)
	{
		a[i] = i;
		PoolTest.AddTask(TestTask, a + i);
	}
	PoolTest.WaitAndEnd();
	cout << "------------------Tasks finished again!\n";
}
  1. 运行结果：可以看到，最多会有8个任务在工作。
    经过多次测试，实验均符合预期。
Task 0 is working!
Task 3 is working!
Task 1 is working!
Task 2 is working!
Task 4 is working!
Task 5 is working!
Task 6 is working!
Task 7 is working!
Task 0 finished!
Task 3 finished!
Task 1 finished!
Task 2 finished!
Task 8 is working!
Task 4 finished!
Task 5 finished!
Task 9 is working!
Task 6 finished!
Task 10 is working!
Task 7 finished!
Task 11 is working!
Task 12 is working!
Task 13 is working!
Task 14 is working!
Task 8 finished!
Task 9 finished!
Task 10 finished!
Task 11 finished!
Task 12 finished!
Task 13 finished!
Task 14 finished!
-------------------all Tasks finished!
Task 15 is working!
Task 20 is working!
Task 19 is working!
Task 17 is working!
Task 18 is working!
Task 16 is working!
Task 21 is working!
Task 22 is working!
Task 15 finished!
Task 23 is working!
Task 20 finished!
Task 19 finished!
Task 24 is working!
Task 17 finished!
Task 25 is working!
Task 18 finished!
Task 26 is working!
Task 16 finished!
Task 21 finished!
Task 27 is working!
Task 22 finished!
Task 28 is working!
Task 29 is working!
Task 23 finished!
Task 24 finished!
Task 25 finished!
Task 26 finished!
Task 27 finished!
Task 28 finished!
Task 29 finished!
---------------------Tasks finished again!
Korpse
关注
  • 26
    点赞
  • 踩
  • 127
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
某里P7程序员推荐，Linux C/C++ 学习路线（内附资料）
pangzizzzz的博客
06-12 498
前言 Linux C/C++ 从零基础到大神的学习路线，自己的真实学习路线，干货很多，建议收藏，认真阅读。 在校期间，我一直走的都是 Linux C/C++ 学习路线，历经暑期实习、秋招决战、校招期间投的大部分岗位都是 Linux C/C++ 后台方向，对于这个方向，有着自己的理解。 从接触 C++ 到我现在正式工作，大概有 2 年多的时间，对于这个方向的学习路线、以及学习编程的方法摸索出来了一些，看完本文，希望对于正在走 Linux C/C++ 路上的同学能有所帮助。 **【文章福利】：**小编推荐一个
C++ 线程池
暮色尽染的博客
07-01 1455
(来自ChatGPT)线程池是一种用于管理和复用线程的机制。它可以提高程序的性能和效率，特别是在处理大量并发任务时。线程池中包含一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，可以将任务提交给线程池，线程池会选择一个可用的线程来执行任务。任务执行完毕后，线程会返回线程池，等待下一个任务的到来。线程池的优点：降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，提高程序的性能。提高系统的响应速度。
C++线程池
weixin_46383092的博客
05-31 6961
线程池 介绍 线程池维护者多个线程，等待着分配可并发执行的任务，可以避免在短时间创建和销毁大量线程带来时间成本。 线程池的优点： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 原理 线程池中有一个阻塞队列，用于存放上层发来的任务请求。 线程池中管理着一批线程，当任
深入解析C++线程池化技术：原理、实现与应用
最新发布
iShare_Carlos的博客
08-03 1130
线程池是一种优化并行任务执行的技术，通过预先创建一组线程用于处理多个任务，线程池通过复用这些已创建的线程来执行任务，避免了频繁创建和销毁线程的开销，从而提高了系统的性能和响应速度。线程池的主要优点包括减少线程创建销毁的开销、提高响应速度、优化资源使用等。在高并发场景下，每次任务都创建和销毁线程会带来显著的系统开销，包括内存分配、线程启动和上下文切换等，而通过使用线程池，系统可以有效地管理和复用线程，减少这些开销。
C++实现线程池
923723914
06-04 432
C++实现线程池。 欢迎转载，转载请注明原出处：http://blog.csdn.net/ithzhang/article/details/9020283 代码地址：https://github.com/ithzhang/ThreadpoolLib.git 本文介绍的线程池采用C++语言，在windows平台下实现。此版本为Version1.0，以后还...
线程池原理及创建
11-14 907
线程池原理及创建本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。为什么需要线程池目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器
线程池c++实现
f593256的博客
01-20 954
线程池（Thread Pool）是一种并发编程的设计模式，它用于管理和重复使用线程，以提高程序的性能和资源利用率。线程池通过维护一组预先创建的线程，这些线程可以在需要时被重复使用，而不是为每个任务都创建一个新的线程。线程池通常包含以下主要组件用于存储待执行的任务。当有新的任务到达时，它被放入任务队列中等待执行。一组预先创建的线程，它们在整个程序的生命周期内一直存在。这些线程从任务队列中获取任务，并执行任务的操作。负责管理线程池的创建、销毁和任务分配等工作。
【C++】实现线程池
m0_67392010的博客
05-19 492
整理自《【C++】《C++ 并发编程实战 (第2版) 》笔记-Chapter9-高级线程管理》 1、线程池类，包括 AJoinThreads、AQueueThreadSafe、ATaskType、AStealTaskQueue、AMyThreadPool。其中， AJoinThreads：RAII思想，析构时调用 join() 自动等待所有线程完成。 AQueueThreadSafe：基于 std::mutex 的线程安全的 queue，用于存放任务。 ATaskType：任务包装类。 AStealTa.
C++ 多线程（一）入门
jianbiancheng的博客
05-17 1297
C++ 多线程（一） Multi-Threaded 多线程编程术语 线程 更确切地说，是执行线程，它是最小的处理单元。 由操作系统调度。 通常它包含在进程中。 因此，同一个进程中可以存在多个线程。它与进程共享资源:内存、代码(指令)和全局变量(上下文——它的变量在任何给定时刻引用的值)。 在单个处理器上，每个线程根据时间进行多路复用；在多处理器上，每个线程同时运行，每个处理器/核心运行一个特定的线程。 为什么用多线程 在应用程序本身中有多个执行线程的应用程序称为多线程应用程序。 例如，如果我们想创
想做C++软件开发工程师,我该如何去学习？
kaikeba的博客
01-20 1480
想做C++软件开发工程师,我该如何去学习？ 因为C++是一个兼具性能和抽象模型结合体，除了能够保证性能之外，还能用当今最流行的面向对象编程模型，而且生态系统由于这些年的积累，建设的也非常完善，所以在高级工程师这个级别C++受到的推崇程度依然非常高，很多架构师没事就喜欢拿C++的东西做研究，甚至还建立长期的学习计划。那么做一名C++软件开发工程师需要学什么呢？ 基础加强+核心提升+综合实战=大厂程序员成长秘籍 基础加强阶段介绍： 本阶段从Linux系统基本操作与使用出发，从零开始将扎实C语言与C++语言基础，
计算机专业的学生，想走Linux C/C++方向，需要学哪些知识才能找到一份不错的工作？
pangzizzzz的博客
08-05 677
前言 Linux C/C++ 从零基础到大神的学习路线，真实学习路线，干货很多，建议收藏，认真阅读。 在校期间，一直走的都是 Linux C/C++ 学习路线，从接触 C++ 到正式工作，大概有 2 年多的时间，对于这个方向的学习路线、以及学习编程的方法摸索出来了一些，看完本文，希望对于正在走 Linux C/C++ 路上的同学能有所帮助。 Linux C/C++ 方向的一些思考 对于方向的抉择，很多人都选择了 Java 或者 Python 方向，Java 或者 Python 方向确实学的人多，岗位需求很多
如何用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); } ``` 以上是一个简单的线程池的实现，通过初始化线程池、添加任务、关闭线程池等操作，可以有效地管理和复用线程，提高应用程序的性能。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值