• 【面试心得】C++ 线程池总结

    什么是线程池

    线程池（Thread Pool）是一种多线程编程的设计模式，它用于管理和复用线程，以有效地执行并发任务。线程池由一组预创建的线程组成，这些线程在需要时被分配来执行任务。线程池的核心思想是将线程的创建、销毁和管理工作从任务执行中分离出来，从而提高性能、资源利用率和代码可维护性。

    线程池的主要目标是解决以下问题：

    1. 减少线程创建和销毁的开销： 在多线程应用程序中，频繁地创建和销毁线程会导致额外的开销，包括内存分配、上下文切换等。线程池在应用程序启动时创建一组线程，并在任务完成后不立即销毁它们，而是将它们保持在池中以供重用。

    2. 控制并发度： 线程池允许您限制同时执行的线程数量，从而控制系统的并发度。这有助于避免过多的并发线程导致系统资源不足或性能下降的问题。

    3. 提高系统的稳定性和可靠性： 通过管理线程的生命周期，线程池可以提高系统的稳定性，避免因线程创建失败或线程泄漏而导致的问题。

    4. 提高代码可维护性： 使用线程池将任务的执行与线程管理分离，使代码更清晰和可维护。您可以专注于任务的逻辑，而不必担心线程的创建和销毁。

    5. 提高性能： 线程池可以提高多核处理器的利用率，充分利用可用的计算资源，从而加速任务的执行。

    总之，线程池是一种有助于管理多线程应用程序的机制，它可以提高性能、资源利用率和代码可维护性，同时降低了多线程编程的复杂性。这就是为什么在许多多线程应用程序中使用线程池的原因。

    线程池工作原理

    1. 初始化： 在线程池启动时，会创建一定数量的线程。这些线程通常被称为工作线程。线程池还会创建一个任务队列，用于存储待执行的任务。

    2. 任务提交： 当应用程序有任务需要执行时，它可以将任务提交到线程池。这些任务通常表示为可调用的函数对象（函数指针、Lambda表达式等）。任务提交后，线程池将任务放入任务队列中等待执行。

    3. 任务调度： 线程池中的工作线程会循环地从任务队列中获取任务。一旦工作线程获取到任务，它就会执行该任务。如果没有可用任务，工作线程会等待，直到有任务可执行。

    4. 任务执行： 工作线程执行从任务队列中获取的任务。任务可以并行执行，因为线程池中有多个工作线程，每个工作线程都可以执行不同的任务。

    5. 任务完成： 任务执行完成后，工作线程可以继续从任务队列中获取下一个任务，或者根据线程池的策略决定是否保持线程处于等待状态以等待更多任务。

    6. 线程复用： 工作线程在执行完任务后不会立即销毁，而是返回线程池中等待下一个任务。这样可以减少线程创建和销毁的开销，并提高性能。

    7. 线程池管理： 线程池通常具有管理功能，可以控制线程的数量、动态调整线程池大小、处理异常、记录日志等。这些管理功能有助于线程池的稳定性和性能优化。

    8. 任务完成通知： 通常，线程池允许应用程序检测任务是否完成，并获取任务的返回结果。这可以通过各种机制实现，如回调函数、Future/Promise等。

    线程池的工作原理允许多个任务在一组工作线程上并发执行，从而提高了系统的性能和资源利用率。线程池还可以根据需要动态调整线程的数量，以适应不同的工作负载。这使得线程池成为处理并发任务的强大工具。

    保障线程池的线程安全

    1. 任务队列的互斥锁： 任务队列是线程池中的关键资源，因此需要使用互斥锁（Mutex）来保护它，确保只有一个线程能够访问或修改任务队列。这样可以避免多个线程同时向队列添加或删除任务而导致的问题。

    2. 条件变量： 除了互斥锁，使用条件变量（Condition Variable）来通知等待任务的线程有新任务可执行。条件变量允许线程等待某个条件满足后再继续执行，这在任务队列为空时非常有用。

    3. 线程池状态管理： 维护线程池的状态，例如标识线程池是否处于运行状态、是否正在销毁等。在操作线程池状态时需要加锁，以确保线程安全。

    4. 资源的合理共享： 确保线程池中的线程在共享资源时进行适当的同步。避免数据竞争问题，如多个线程同时修改同一个变量。

    5. 异常处理： 考虑线程中可能出现的异常情况，特别是在任务执行时，确保异常不会导致线程池崩溃。可以使用 try-catch 块捕获异常，记录日志或采取适当的措施。

    6. 资源管理： 确保线程池中的线程在退出时释放资源，如内存、文件句柄等。防止资源泄漏。

    7. 使用原子操作： 在需要对共享变量进行增减等操作时，使用原子操作，以确保操作的原子性，避免竞态条件。

    代码实现

    版本一

    xthread_pool.h

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. class XTask
    9. {
    10. public:
    11.     virtual int Run() = 0;
    12.     std::function<bool()> is_exit = nullptr;
    13. };
    14.  
    15. class XThreadPool
    16. {
    17. public:
    18.     //
    19.     /// 初始化线程池
    20.     /// @para num 线程数量
    21.     void Init(int num);
    22.  
    23.     //
    24.     /// 启动所有线程，必须先调用Init
    25.     void Start();
    26.  
    27.     //
    28.     /// 线程池退出
    29.     void Stop();
    30.  
    31.     void AddTask(XTask* task);
    32.  
    33.     XTask* GetTask();
    34.  
    35.     //线程池是否退出
    36.     bool is_exit() { return is_exit_; }
    37.  
    38.     int task_run_count() { return task_run_count_; }
    39. private:
    40.     //线程池线程的入口函数
    41.     void Run() ;
    42.     int thread_num_ = 0;//线程数量
    43.     std::mutex mux_;
    44.     std::vector threads_;
    45.     std::list tasks_;
    46.     std::condition_variable cv_;
    47.     bool is_exit_ = false; //线程池退出
    48.  
    49.     //正在运行的任务数量,线程安全
    50.     std::atomic<int> task_run_count_ = {0};
    51. };

     xthread_pool.cpp

    1. #include "xthread_pool.h"
    2. #include 
    3. using namespace std;
    4.  
    5. //
    6. /// 初始化线程池
    7. /// @para num 线程数量
    8. void XThreadPool::Init(int num)
    9. {
    10.     unique_lock lock(mux_);
    11.     this->thread_num_ = num;
    12.     cout << "Thread pool Init " << num << endl;
    13. }
    14.  
    15. //
    16. /// 启动所有线程，必须先调用Init
    17. void XThreadPool::Start()
    18. {
    19.     unique_lock lock(mux_);
    20.     if (thread_num_ <= 0)
    21.     {
    22.         cerr << "Please Init XThreadPool" << endl;
    23.         return;
    24.     }
    25.     if (!threads_.empty())
    26.     {
    27.         cerr << "Thread pool has start!" << endl;
    28.         return;
    29.     }
    30.     //启动线程
    31.     for (int i = 0; i < thread_num_; i++)
    32.     {
    33.         auto th = new thread(&XThreadPool::Run, this);
    34.         threads_.push_back(th);
    35.     }
    36. }
    37. //
    38. /// 线程池退出
    39. void XThreadPool::Stop()
    40. {
    41.     is_exit_ = true;
    42.     cv_.notify_all();
    43.     for (auto& th : threads_)
    44.     {
    45.         th->join();
    46.     }
    47.     unique_lock lock(mux_);
    48.     threads_.clear();
    49. }
    50. //线程池线程的入口函数
    51. void XThreadPool::Run()
    52. {
    53.     cout << "begin XThreadPool Run " << this_thread::get_id() << endl;
    54.     while (!is_exit())
    55.     {
    56.         auto task = GetTask();
    57.         if (!task)continue;
    58.         ++task_run_count_;
    59.         try
    60.         {
    61.             task->Run();
    62.         }
    63.         catch (...)
    64.         {
    65.  
    66.         }
    67.         --task_run_count_;
    68.     }
    69.  
    70.     cout << "end XThreadPool Run " << this_thread::get_id() << endl;
    71. }
    72.  
    73. void XThreadPool::AddTask(XTask* task)
    74. {
    75.     unique_lock lock(mux_);
    76.     tasks_.push_back(task);
    77.     task->is_exit = [this] {return is_exit(); };
    78.  
    79.     lock.unlock();
    80.     cv_.notify_one();
    81. }
    82.  
    83. XTask* XThreadPool::GetTask()
    84. {
    85.     unique_lock lock(mux_);
    86.     if (tasks_.empty())
    87.     {
    88.         cv_.wait(lock);
    89.     }
    90.     if (is_exit())
    91.         return nullptr;
    92.     if (tasks_.empty())
    93.         return nullptr;
    94.     auto task = tasks_.front();
    95.     tasks_.pop_front();
    96.     return task;
    97. }

    main.cpp 

    1. #include "xthread_pool.h"
    2. #include 
    3. using namespace std;
    4. class MyTask :public XTask
    5. {
    6. public:
    7.     int Run()
    8.     {
    9.         cout << "================================================" << endl;
    10.         cout << this_thread::get_id()<<" Mytask " << name << endl;
    11.         cout << "================================================" << endl;
    12.         for (int i = 0; i < 10; i++)
    13.         {
    14.             if (is_exit())break;
    15.             cout << "." << flush;
    16.             this_thread::sleep_for(500ms);
    17.         }
    18.         return 0;
    19.     }
    20.     std::string name = "";
    21. };
    22. int main(int argc, char* argv[])
    23. {
    24.   
    25.     XThreadPool pool;
    26.     pool.Init(16);
    27.     pool.Start();
    28.  
    29.     MyTask task1;
    30.     task1.name = "test name 001";
    31.     pool.AddTask(&task1);
    32.  
    33.     MyTask task2;
    34.     task2.name = "test name 002";
    35.     pool.AddTask(&task2);
    36.     this_thread::sleep_for(100ms);
    37.     cout << "task run  count = " << pool.task_run_count() << endl;
    38.  
    39.  
    40.     this_thread::sleep_for(1s);
    41.     pool.Stop();
    42.     cout << "task run  count = " << pool.task_run_count() << endl;
    43.  
    44.     getchar();
    45.     return 0;
    46. }
    版本二（智能指针）

    xthread_pool.h

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. class XTask
    9. {
    10. public:
    11.     virtual int Run() = 0;
    12.     std::function<bool()> is_exit = nullptr;
    13. };
    14.  
    15. class XThreadPool
    16. {
    17. public:
    18.     //
    19.     /// 初始化线程池
    20.     /// @para num 线程数量
    21.     void Init(int num);
    22.  
    23.     //
    24.     /// 启动所有线程，必须先调用Init
    25.     void Start();
    26.  
    27.     //
    28.     /// 线程池退出
    29.     void Stop();
    30.  
    31.     //void AddTask(XTask* task);
    32.     void AddTask(std::shared_ptr task);
    33.  
    34.     std::shared_ptr GetTask();
    35.  
    36.     //线程池是否退出
    37.     bool is_exit() { return is_exit_; }
    38.  
    39.     int task_run_count() { return task_run_count_; }
    40. private:
    41.     //线程池线程的入口函数
    42.     void Run() ;
    43.     int thread_num_ = 0;//线程数量
    44.     std::mutex mux_;
    45.     //std::vector threads_;
    46.     //线程列表 指针指针版本
    47.     std::vector< std::shared_ptr > threads_;
    48.  
    49.     //std::list tasks_;
    50.     std::list > tasks_;
    51.     
    52.     std::condition_variable cv_;
    53.     bool is_exit_ = false; //线程池退出
    54.  
    55.     //正在运行的任务数量,线程安全
    56.     std::atomic<int> task_run_count_ = {0};
    57. };

    xthread_pool.cpp 

    1. #include "xthread_pool.h"
    2. #include 
    3. using namespace std;
    4.  
    5. //
    6. /// 初始化线程池
    7. /// @para num 线程数量
    8. void XThreadPool::Init(int num)
    9. {
    10.     unique_lock lock(mux_);
    11.     this->thread_num_ = num;
    12.     cout << "Thread pool Init " << num << endl;
    13. }
    14.  
    15. //
    16. /// 启动所有线程，必须先调用Init
    17. void XThreadPool::Start()
    18. {
    19.     unique_lock lock(mux_);
    20.     if (thread_num_ <= 0)
    21.     {
    22.         cerr << "Please Init XThreadPool" << endl;
    23.         return;
    24.     }
    25.     if (!threads_.empty())
    26.     {
    27.         cerr << "Thread pool has start!" << endl;
    28.         return;
    29.     }
    30.     //启动线程
    31.     for (int i = 0; i < thread_num_; i++)
    32.     {
    33.         //auto th = new thread(&XThreadPool::Run, this);
    34.         auto th = make_shared(&XThreadPool::Run, this);
    35.         threads_.push_back(th);
    36.     }
    37. }
    38. //
    39. /// 线程池退出
    40. void XThreadPool::Stop()
    41. {
    42.     is_exit_ = true;
    43.     cv_.notify_all();
    44.     for (auto& th : threads_)
    45.     {
    46.         th->join();
    47.     }
    48.     unique_lock lock(mux_);
    49.     threads_.clear();
    50. }
    51. //线程池线程的入口函数
    52. void XThreadPool::Run()
    53. {
    54.     cout << "begin XThreadPool Run " << this_thread::get_id() << endl;
    55.     while (!is_exit())
    56.     {
    57.         auto task = GetTask();
    58.         if (!task)continue;
    59.         ++task_run_count_;
    60.         try
    61.         {
    62.             task->Run();
    63.         }
    64.         catch (...)
    65.         {
    66.  
    67.         }
    68.         --task_run_count_;
    69.     }
    70.  
    71.     cout << "end XThreadPool Run " << this_thread::get_id() << endl;
    72. }
    73.  
    74. void XThreadPool::AddTask(std::shared_ptr task)
    75. {
    76.     unique_lock lock(mux_);
    77.     tasks_.push_back(task);
    78.     task->is_exit = [this] {return is_exit(); };
    79.     lock.unlock();
    80.     cv_.notify_one();
    81. }
    82.  
    83. std::shared_ptr XThreadPool::GetTask()
    84. {
    85.     unique_lock lock(mux_);
    86.     if (tasks_.empty())
    87.     {
    88.         cv_.wait(lock);
    89.     }
    90.     if (is_exit())
    91.         return nullptr;
    92.     if (tasks_.empty())
    93.         return nullptr;
    94.     auto task = tasks_.front();
    95.     tasks_.pop_front();
    96.     return task;
    97. }

     main.cpp

    1. #include "xthread_pool.h"
    2. #include 
    3. using namespace std;
    4. class MyTask :public XTask
    5. {
    6. public:
    7.     int Run()
    8.     {
    9.         cout << "================================================" << endl;
    10.         cout << this_thread::get_id()<<" Mytask " << name << endl;
    11.         cout << "================================================" << endl;
    12.         for (int i = 0; i < 10; i++)
    13.         {
    14.             if (is_exit())break;
    15.             cout << "." << flush;
    16.             this_thread::sleep_for(500ms);
    17.         }
    18.         return 0;
    19.     }
    20.     std::string name = "";
    21. };
    22. int main(int argc, char* argv[])
    23. {
    24.   
    25.     XThreadPool pool;
    26.     pool.Init(16);
    27.     pool.Start();
    28.  
    29.     {
    30.         auto task3 = make_shared();
    31.         task3->name = "test shared 003";
    32.         pool.AddTask(task3);
    33.  
    34.         auto task4 = make_shared();
    35.         task4->name = "test shared 004";
    36.         pool.AddTask(task4);
    37.     }
    38.     this_thread::sleep_for(100ms);
    39.     cout << "task run  count = " << pool.task_run_count() << endl;
    40.  
    41.  
    42.     this_thread::sleep_for(1s);
    43.     pool.Stop();
    44.     cout << "task run  count = " << pool.task_run_count() << endl;
    45.  
    46.     getchar();
    47.     return 0;
    48. }

  • 相关阅读:
    软件设计模式系列之二十五——访问者模式
    Team Finance被黑分析｜黑客自建Token“瞒天过海”，成功套取1450万美元
    考前必看科目一交警手势图解_准橙考试网
    详解mfc140.dll文件，修复mfc140.dll缺失的多种方法
    MySQL 触发器实例解析：自动更新垃圾桶颜色
    CocosCreator3.8研究笔记（十五）CocosCreator 资源管理Asset Bundle
    浏览器截图扩展增加快捷键
    你有用过 java中的栈和队列吗？怎么用栈来实现队列呢
    R语言矩阵数据初始化：创建全为0的矩阵、全为NA的矩阵、使用byrow参数指定数据排布方式（按行、按列）、dim参数指定矩阵维度信息
    【Python脚本进阶】2.2、构建一个SSH僵尸网络（下）：利用SSH中的弱私钥
  • 原文地址：https://blog.csdn.net/weixin_42809675/article/details/132802041