【Linux】基于单例模式的线程池设计

最新推荐文章于 2026-01-01 12:38:51 发布

原创最新推荐文章于 2026-01-01 12:38:51 发布 · 1.9k 阅读

45 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Linux

📝前言：

这篇文章我们来讲讲Linux——基于单例模式的线程池设计

🎬个人简介：努力学习ing
📋个人专栏：Linux
🎀CSDN主页愚润求学
🌄其他专栏：C++学习笔记，C语言入门基础，python入门基础，C++刷题专栏

这里写目录标题

一，设计框架
二，实现代码
三，测试结果
四，线程安全和重入问题
五、锁的其他问题
六、STL和智能指针的线程安全

一，设计框架

1. 总体框架

我们需要的模块

日志Mylog：用于DEBUG
线程MyThread：用于生成多个线程
线程池ThreadPool，利用前两个模块来实现一个线程池

2. 线程池模块

2.1 什么是线程池

线程池 是一种多线程处理模式，属于池化技术的一种。它通过提前创建并管理一定数量的线程，重复利用这些线程处理任务，避免了频繁创建和销毁线程的开销，从而提升系统性能和资源利用率

2.2 设计思路

我们用一个queue来存储待处理的任务
用一个vector来存储线程

3. 什么是单例模式

某些类, 只应该具有⼀个对象(实例), 就称之为单例

通常把构造函数，拷贝，赋值…设置成私有，或者直接禁用（在外部无法创建实例）
只保留一个static实例成员，这样类在被加载的时候，这个实例就存在了。（static成员不属于任何一个对象，而属于类，只有一份）
- 注意static成员的初始化是在类外的（但是属于类的一部分，可以访问类的私有成员）
然后提供一个public的接口来返回这个实例给外部使用

3.1 饿汉模式

加载类的时候，直接创建整个static实例成员
问题：如果静态实例的体积大，则加载时间长

3.2 懒汉模式（更推荐）

延迟加载，我只定义静态成员实例的指针。
当真正使用到这个成员时，再创建并赋值给指针（这样可以提高内存使用率）
- 即：在GetInstance时发现指针为空再创建

可是还有几个设计上的问题：

没有实例，我们怎么调GetInstance创造实例？
- 所以GetInstance也是Static的
获取实例不是线程安全的，要加锁（不然可能创建多个实例）
- 这个锁是什么锁？也需要是static的锁，因为没实例的时候拿不到类的锁。

二，实现代码

细节我就不讲了，感兴趣的可以看注释

#pragma once
#include "MyThread.hpp"
#include "Mylog.hpp"
#include <vector>
#include <queue>
#include "Task.hpp"
#include <mutex>
#include <condition_variable>

// 先不考虑单例模式
using namespace std;
using namespace tr;

template <typename T> // 任务类型
class ThreadPool
{
private:
    ThreadPool(int th_num = 3)
        : _th_num(th_num),
          _isrunning(false),
          _wait_thread(0)

    {
    }

    void HandlerTask() // 单个线程处理任务的方法
    {
        while (true)
        {
            LOG(LogLevel::DEBUG) << GetThreadName() << " is running";
            _mutex.lock();
            while (_tasks_queue.empty() && _isrunning) // 条件变量一定要注意虚假唤醒
            {
                _wait_thread++;
                // LOG(LogLevel::DEBUG) << GetThreadName() << " is waiting";
                _cond.wait(_mutex);
                // LOG(LogLevel::DEBUG) << GetThreadName() << " is waked";
                _wait_thread--; // 如果等待被唤醒(唤醒是由别的地方唤醒的)
            }
            // 如果还有任务就先不退
            if (_tasks_queue.empty() && !_isrunning)
            {
                _mutex.unlock(); // 尽早释放锁
                LOG(LogLevel::DEBUG) << GetThreadName() << " quit";
                break;
            }

            T t = _tasks_queue.front();
            _tasks_queue.pop();
            _mutex.unlock(); // 尽早释放锁
            LOG(LogLevel::DEBUG) << GetThreadName() << " 获得一个任务...";
            t(); // 处理任务
        }
    }

    void Start() // 启动线程池
    {
        if (!_isrunning)
        {
            LOG(LogLevel::DEBUG) << "启动线程池...";
            _isrunning = true;
            // 必须要先开空间（因为扩容不是线程安全的）
            // 1. 创建 Mythread 对象
            // 2. 启动线程（线程开始执行HandlerTask）
            // 3. vector扩容（移动现有线程对象，原来的迭代器失效）
            // 如果 3. 的时候有线程在执行 HandlerTask，则原 this 指针会失效（导致段错误）
            // 以上为个人理解
            _threads.reserve(_th_num);
            // lock_guard<mutex> lock(_mutex); 不能这样做，又是为什么呢？？？
            for (int i = 0; i < _th_num; i++)
            {
                // 用 HandlerTask（需要捕捉 this指针） 构造 Mythread 临时对象（隐式类型转换），
                _threads.emplace_back(
                    [this]()
                    {
                        HandlerTask();
                    });
            }
        }
        else
            LOG(LogLevel::DEBUG) << "线程池已经启动, 请勿重复启动...";
    }

    // 禁用拷贝和赋值
    ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;
    ThreadPool(const ThreadPool<T> &) = delete;

public:
    static ThreadPool<T> *GetInstance()
    {
        if (_instance == nullptr)
        {
            _lock.lock();
            if (_instance == nullptr) // 双层 if 判断，只有一个线程能拿到锁进入这里，不会全部线程都通过这个判断
            {
                _instance = new ThreadPool<T>();
                _instance->Start(); // 启动线程池
                LOG(LogLevel::DEBUG) << " 创建线程池单例" ;
                return _instance;
            }
        }
        LOG(LogLevel::DEBUG) << " 获取线程池单例";
        return _instance;
    }

    void Stop() // 暂停（结束）线程池
    {
        lock_guard<mutex> lock(_mutex);
        if (!_isrunning)
            return;
        _isrunning = false;
        // 唤醒所有线程，让线程知道 _isrunning 已经为 false 了
        _cond.notify_all();
        LOG(LogLevel::INFO) << "线程池退出...";
    }

    void Wait() // 等待所有线程
    {
        for (auto &th : _threads)
        {
            // LOG(LogLevel::INFO) << th.GetName() << " 退出...";
            th.Join();
        }
    }

    void Enqueue(const T &task) // 入队任务
    {
        lock_guard<mutex> lock(_mutex);
        if (_isrunning)
        {
            _tasks_queue.push(task);
            // LOG(LogLevel::INFO) << "插入了一个任务";
            if (_wait_thread > 0)
                _cond.notify_one();
        }
    }

    ~ThreadPool()
    {
    }

private:
    bool _isrunning;
    queue<T> _tasks_queue;
    vector<Mythread> _threads;
    int _th_num; // 线程数量
    int _wait_thread;
    mutex _mutex; // 标准库的锁不用初始化
    condition_variable_any _cond;

    static ThreadPool<T> *_instance; // 静态成员实例
    static mutex _lock;
};

template <typename T>                              // 模板类静态成员初始化必须带 template <typename T>, 因为模版要实例化
ThreadPool<T> *ThreadPool<T>::_instance = nullptr; // 还要声明模版的作用域
template <typename T>
mutex ThreadPool<T>::_lock;