【探索Linux】P.23（线程池 —— 简单模拟）

  
引言

在Linux下，线程池是一种常见的并发编程模型，它能够有效地管理多个线程，提高系统的性能和资源利用率。通过线程池，可以实现多生产者多消费者模型，有效地处置惩罚并发任务，提升系统的响应速度和吞吐量。在本文中，我们将深入探讨怎样在Linux情况下创建线程池，以及线程池的实现原理和使用本事。通过深入明白线程池的概念和应用，我们可以更好地应对复杂的并发编程场景，从而提升系统的稳固性和性能表现。让我们一起探索Linux下线程池的奥秘，为并发编程的天下增添新的色彩！
一、线程池简单介绍

线程池是一种并发编程技术，用于管理和复用多个线程，以提高系统的性能和资源利用率。在线程池中，肯定命量的线程被预先创建并保存在池中，当需要执行任务时，从线程池中选择一个空闲的线程来处置惩罚任务，任务执行完毕后，线程将返回到线程池中等待下一个任务。
通过使用线程池，可以克制频仍地创建和销毁线程，减少了线程创建和销毁的开销，同时也控制了并发线程的数量，克制系统资源被过度占用。线程池还可以根据系统负载情况动态调整线程数量，以更好地顺应不同的工作负载。
二、Linux下线程池代码

⭕Makefile文件

1. thread_pool:testMain.cpp
2.         g++ -o $@ $^ -std=c++11 -lpthread #-DDEBUG_SHOW
3. clean:
4.         rm -f thread_pool

复制代码

这个 Makefile 包含了两个规则：一个用于编译名为"testMain.cpp"的程序并天生名为"thread_pool"的可执行文件，另一个用于清算天生的可执行文件。你可以使用"make"命令编译程序，使用"make clean"命令清算天生的可执行文件。
⭕ . h 头文件

✅Task.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <functional>
7. // 定义函数类型 func_t，用于表示可以接受两个整型参数并返回一个整型结果的函数
8. typedef std::function<int(int, int)> func_t;
10. // Task 类，表示一个任务
11. class Task
12. {
13. public:
14.     // 默认构造函数
15.     Task() {}
17.     // 带参数的构造函数，初始化任务的成员变量
18.     Task(int x, int y, func_t func) : x_(x), y_(y), func_(func)
19.     {}
21.     // 重载 () 运算符，实现任务的执行
22.     void operator()(const std::string &name)
23.     {
24.         // 在控制台输出任务执行的结果
25.         std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;
26.     }
28. public:
29.     int x_; // 任务的参数 x
30.     int y_; // 任务的参数 y
31.     func_t func_; // 保存任务所需执行的函数
32. };

复制代码

✅thread.hpp

1. #pragma once
2. #include <iostream>
3. #include <string>
4. #include <cstdio>
6. // 定义函数指针类型 fun_t，表示可以接受一个 void* 类型参数并返回一个 void* 类型结果的函数指针
7. typedef void *(*fun_t)(void *);
9. // 线程数据结构，用于保存线程的参数和名称
10. class ThreadData
11. {
12. public:
13.     void *args_; // 线程参数
14.     std::string name_; // 线程名称
15. };
17. // 线程类，用于创建和管理线程
18. class Thread
19. {
20. public:
21.     // 构造函数，初始化线程对象
22.     Thread(int num, fun_t callback, void *args) : func_(callback)
23.     {
24.         // 设置线程名称为 "Thread-num"
25.         char nameBuffer[64];
26.         snprintf(nameBuffer, sizeof nameBuffer, "Thread-%d", num);
27.         name_ = nameBuffer;
29.         // 设置线程数据的参数和名称
30.         tdata_.args_ = args;
31.         tdata_.name_ = name_;
32.     }
34.     // 启动线程
35.     void start()
36.     {
37.         pthread_create(&tid_, nullptr, func_, (void*)&tdata_);
38.     }
40.     // 等待线程结束
41.     void join()
42.     {
43.         pthread_join(tid_, nullptr);
44.     }
46.     // 获取线程名称
47.     std::string name()
48.     {
49.         return name_;
50.     }
52.     // 析构函数
53.     ~Thread()
54.     {
55.     }
57. private:
58.     std::string name_; // 线程名称
59.     fun_t func_;       // 线程执行的函数指针
60.     ThreadData tdata_; // 线程数据
61.     pthread_t tid_;    // 线程 ID
62. };

复制代码

✅threadPool.hpp

1. #pragma once
2. #include <iostream>
3. #include <vector>
4. #include <string>
5. #include <queue>
6. #include <unistd.h>
7. #include "thread.hpp"
9. // 互斥锁类，封装了互斥锁的操作
10. class Mutex
11. {
12. public:
13.     Mutex(pthread_mutex_t *mtx) : pmtx_(mtx)
14.     {
15.     }
16.     void lock()
17.     {
18.         pthread_mutex_lock(pmtx_);
19.     }
20.     void unlock()
21.     {
22.         pthread_mutex_unlock(pmtx_);
23.     }
24.     ~Mutex()
25.     {
26.     }
28. private:
29.     pthread_mutex_t *pmtx_;
30. };
32. // RAII风格的加锁方式，构造时加锁，析构时解锁
33. class lockGuard
34. {
35. public:
36.     lockGuard(pthread_mutex_t *mtx) : mtx_(mtx)
37.     {
38.         mtx_.lock();
39.     }
40.     ~lockGuard()
41.     {
42.         mtx_.unlock();
43.     }
45. private:
46.     Mutex mtx_;
47. };
49. // 默认线程数
50. const int g_thread_num = 3;
52. // 线程池类模板
53. template <class T>
54. class ThreadPool
55. {
56. public:
57.     // 获取互斥锁指针
58.     pthread_mutex_t *getMutex()
59.     {
60.         return &lock;
61.     }
62.     // 判断任务队列是否为空
63.     bool isEmpty()
64.     {
65.         return task_queue_.empty();
66.     }
67.     // 等待条件变量
68.     void waitCond()
69.     {
70.         pthread_cond_wait(&cond, &lock);
71.     }
72.     // 获取待执行任务
73.     T getTask()
74.     {
75.         T t = task_queue_.front();
76.         task_queue_.pop();
77.         return t;
78.     }
80. private:
81.     // 构造函数，初始化线程池
82.     ThreadPool(int thread_num = g_thread_num) : num_(thread_num)
83.     {
84.         pthread_mutex_init(&lock, nullptr);
85.         pthread_cond_init(&cond, nullptr);
86.         for (int i = 1; i <= num_; i++)
87.         {
88.             threads_.push_back(new Thread(i, routine, this));
89.         }
90.     }
91.     ThreadPool(const ThreadPool<T> &other) = delete;
92.     const ThreadPool<T> &operator=(const ThreadPool<T> &other) = delete;
94. public:
95.     // 获取线程池单例
96.     static ThreadPool<T> *getThreadPool(int num = g_thread_num)
97.     {
98.         if (nullptr == thread_ptr)
99.         {
100.             lockGuard lockguard(&mutex);
101.             if (nullptr == thread_ptr)
102.             {
103.                 thread_ptr = new ThreadPool<T>(num);
104.             }
105.         }
106.         return thread_ptr;
107.     }
108.     // 启动线程池中的线程
109.     void run()
110.     {
111.         for (auto &iter : threads_)
112.         {
113.             iter->start();
114.             std::cout << iter->name() << " 启动成功" << std::endl;
115.         }
116.     }
117.     // 线程执行的函数
118.     static void *routine(void *args)
119.     {
120.         ThreadData *td = (ThreadData *)args;
121.         ThreadPool<T> *tp = (ThreadPool<T> *)td->args_;
122.         while (true)
123.         {
124.             T task;
125.             {
126.                 lockGuard lockguard(tp->getMutex());
127.                 while (tp->isEmpty())
128.                     tp->waitCond();
129.                 task = tp->getTask();
130.             }
131.             task(td->name_);
132.         }
133.     }
134.     // 向任务队列中添加任务
135.     void pushTask(const T &task)
136.     {
137.         lockGuard lockguard(&lock);
138.         task_queue_.push(task);
139.         pthread_cond_signal(&cond);
140.     }
141.     // 析构函数，销毁线程池
142.     ~ThreadPool()
143.     {
144.         for (auto &iter : threads_)
145.         {
146.             iter->join();
147.             delete iter;
148.         }
149.         pthread_mutex_destroy(&lock);
150.         pthread_cond_destroy(&cond);
151.     }
153. private:
154.     std::vector<Thread *> threads_; // 线程对象数组
155.     int num_; // 线程数量
156.     std::queue<T> task_queue_; // 任务队列
158.     static ThreadPool<T> *thread_ptr; // 线程池单例指针
159.     static pthread_mutex_t mutex; // 线程池单例的互斥锁
161.     pthread_mutex_t lock; // 线程池内部使用的互斥锁
162.     pthread_cond_t cond; // 线程池内部使用的条件变量
163. };
165. // 静态成员初始化
166. template <typename T>
167. ThreadPool<T> *ThreadPool<T>::thread_ptr = nullptr;
169. template <typename T>
170. pthread_mutex_t ThreadPool<T>::mutex = PTHREAD_MUTEX_INITIALIZER;

复制代码

⭕ . cpp 文件

✅testMain.cpp

1. #include "threadPool.hpp" // 包含线程池头文件
2. #include "Task.hpp" // 包含任务类的头文件
3. #include <ctime>
4. #include <cstdlib>
5. #include <iostream>
6. #include <unistd.h>
8. int main()
9. {
10.     srand((unsigned long)time(nullptr) ^ getpid()); // 初始化随机数种子
12.     // 获取线程池单例并运行线程
13.     ThreadPool<Task>::getThreadPool()->run();
15.     while(true)
16.     {
17.         // 生产任务的过程，制作任务的时候，要花时间
18.         int x = rand() % 100 + 1; // 随机生成一个范围在1到100之间的整数x
19.         usleep(7721); // 模拟制作任务需要的时间
20.         int y = rand() % 30 + 1; // 随机生成一个范围在1到30之间的整数y
21.         Task t(x, y, [](int x, int y) -> int { // 创建任务对象t，执行加法操作
22.             return x + y;
23.         });
25.         std::cout << "制作任务完成: " << x << "+" << y << "=?" << std::endl; // 输出任务信息
27.         // 推送任务到线程池中
28.         ThreadPool<Task>::getThreadPool()->pushTask(t);
30.         sleep(1); // 暂停一秒钟
31.     }
32.     return 0;
33. }

复制代码

这段代码主要实现了一个简单的任务生产者，不断地天生任务并将任务推送到线程池中执行。
三、线程池的优点

线程池能够有效地管理线程，提高系统的性能和响应速度，同时简化了线程管理的复杂性，是多线程编程中常用的一种技术。下面是它的优点

• 提高性能：线程池可以减少线程创建和销毁的开销，通过重用线程，克制了频仍地创建和销毁线程所带来的性能消耗。
  
• 控制并发度：线程池可以限定同时执行的线程数量，从而控制系统的并发度，防止由于过多线程导致系统资源被耗尽。
  
• 提高响应速度：由于线程池中的线程已经创建好并处于就绪状态，当任务到达时可以立即执行，从而减少了任务等待执行的时间，提高了系统的响应速度。
  
• 简化线程管理：线程池封装了线程的创建、销毁、调理等操作，简化了线程管理的复杂性，提高了代码的可维护性。
  
• 控制资源占用：线程池可以限定系统中同时存在的线程数量，从而控制系统对资源（如内存、CPU）的占用，防止资源被耗尽导致系统瓦解。
  

总而言之，线程池提供了一种高效、可控的线程管理机制，实用于处置惩罚大量并发任务的场景，是提高系统性能和响应速度的紧张工具之一。
温馨提示

感谢您对博主文章的关注与支持！假如您喜欢这篇文章，可以点赞、评论和分享给您的同砚，这将对我提供巨大的鼓励和支持。另外，我筹划在未来的更新中持续探讨与本文相干的内容。我会为您带来更多关于Linux以及C++编程技术问题的深入解析、应用案例和趣味玩法等。假如感兴趣的话可以关注博主的更新，不要错过任何精彩内容！
再次感谢您的支持和关注。我们期待与您创建更紧密的互动，共同探索Linux、C++、算法和编程的奥秘。祝您生存愉快，排便顺畅！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。