• 线程池的实现

    目录

    一、线程池的实现

    1.什么是线程池

    2.设计线程类

    3.设计线程池类

    4.运行

    5.RAII加锁改造

    二、利用单例模式改造线程池

    1.复习

    2.饿汉模式

    3.懒汉模式

    关于系统编程的知识我们已经学完了，最后我们需要利用之前写过的代码实现一个线程池，彻底结束系统编程部分。

    一、线程池的实现

    1.什么是线程池

    线程池是一种多线程处理形式，先将任务添加到队列，创建线程后线程池会自动启动线程处理这些任务。

    线程池有以下特点：

    • 线程池是一种线程使用模式，如果线程过多会，就会带来调度开销，进而影响缓存局部性和整体性能。
    • 线程池维护着多个线程，可以处理监督管理者分配的可并发执行的任务。
    • 线程池维护的多个线程在无任务时会处于阻塞等待状态，当有任务需要处理时，线程就会被唤醒，处理完成后继续阻塞等待而不销毁。这样的设置避免了处理短时间任务时调用系统调用创建与销毁线程的开销。
    • 线程池不仅能够保证内核的充分利用，还能防止过分调度。
    • 可用线程数量取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

    2.设计线程类

    设计线程池就需要一个线程类管理线程，之前封装的classThread我们增加了一个Context类，这次我们想只使用一个类就完成线程的管理。

    虽然需要重新设计，但是原来的函数有一部分也能使用。

    线程类的设计思路：

    • 成员变量包括线程的名字、线程的tid、外部定义的线程执行函数对象、线程执行函数需要传递的参数还有一个静态的线程的编号，静态变量需要在类外定义。
    • 对函数对象的类型重命名也可以增加代码可读性。
    • 构造函数只需要初始化线程名即可，线程的创建会在其他地方实现。
    • 我们创建一个start函数负责线程的创建，它有两个参数func和args，func是我们需要传入的线程处理函数，args是处理函数的参数。
    • 在线程创建的时候，具体的执行函数不要设为_func，这样会增加程序的耦合度。
    • 我们再创建一个start_routine函数负责线程的处理，由于它的返回值应该为void*，只有一个参数void* args，该函数必须设置为静态才能去掉默认的this指针参数。
    • start_routine的args还是要用于传递this指针，只是因为线程处理函数的特殊要求，我们才没有直接将其定义为成员函数。而且这个函数也应该定义为私有函数，防止使用者在类外调用该函数。
    • start_routine使用回调函数callback调用_func并传回结果。
    • 注意只有在回调函数中传递的是_args，另一个args是this指针。
    • 最后加上一个获取线程名的函数。

    最终实现的Thread.hpp

    1. #include
    2. #include
    3. #include
    4. #define NUM 64
    5.  
    6. class Thread
    7. {
    8.     typedef std::function<void*(void*)> func_t;
    9. public:
    10.     //构造函数创建线程
    11.     Thread()
    12.     {
    13.         //对线程进行规范化命名
    14.         char buffer[NUM];
    15.         snprintf(buffer, sizeof(buffer), "thread%d", _threadnum++);
    16.         _name = buffer;
    17.     }
    18.  
    19.     //启动线程
    20.     void start(func_t func, void* args = nullptr)
    21.     {
    22.         //初始化这两个变量
    23.         _args = args;
    24.         _func = func;
    25.         //创建线程，线程的处理函数为start_routine
    26.         int n = pthread_create(&_tid, nullptr, start_routine, (void*)this);//将this指针传递到执行代码中
    27.         //断言创建成功，这里也可以换成打印错误码的代码
    28.         assert(n == 0);
    29.     }
    30.  
    31.     //利用回调函数
    32.     void* callback()
    33.     {
    34.         return _func(_args);
    35.     }
    36.  
    37.     //获取线程的名字
    38.     std::string threadname()
    39.     {
    40.         return std::string(_name);
    41.     }
    42.  
    43.     void join()
    44.     {
    45.         int n = pthread_join(_tid, nullptr);
    46.         assert(n == 0);
    47.     }
    48. private:
    49.     //处理函数的函数能只有一个确定的参数，所以只能定义为静态。
    50.     static void* start_routine(void* args)//用args传递this指针
    51.     {
    52.         Thread* pt = static_cast(args);
    53.         return pt->callback();
    54.     }
    55.  
    56.     std::string _name;
    57.     pthread_t _tid;
    58.     func_t _func; 
    59.     void* _args;
    60.     static int _threadnum;
    61. };
    62.  
    63. int Thread::_threadnum = 1;

    我们测试该类

    test.cc

    1. #include
    2. #include
    3. #include"Thread.hpp"
    4.  
    5. using namespace std;
    6.  
    7. void* test(void* args)
    8. {
    9.     char* p = (char*)args;
    10.     while(1)
    11.     {
    12.         printf("%s\n", p);
    13.         sleep(1);
    14.     }
    15. }
    16.  
    17. int main()
    18. {
    19.     Thread t;
    20.     t.start(test, (void*)"thread running");
    21.     t.join();
    22.     return 0;
    23. }

    线程可以正常运行：

    3.设计线程池类

    线程池类负责多线程的创建和维护，并且在基于阻塞队列的生产者消费者模型下运行。其中生产者是生成任务的线程，消费者是线程池维护的多个线程，数据结构为阻塞队列。线程池包括阻塞队列和所有消费者。

    线程池类的设计思路：

    • 成员变量包含线程池维护的线程数量_num、存放线程类Threads的vector容器_threads，存放任务的阻塞队列_queue、保证消费者线程互斥访问任务队列的锁_cmutex、让多线程同步的条件变量_cond、保证生产者互斥生产数据的锁_pmutex。
    • 首先构造中设置线程数量_num为缺省值，这样可以让用户决定线程的数量。然后将互斥锁和条件变量初始化，最后后创建_num个Thread对象并将指针尾插到_threads容器中。此时线程只有名字，还未被创建。
    • 然后实现析构函数，在其中将互斥锁和条件变量销毁，循环释放_threads容器中的所有线程回收并将Thread对象也全部delete掉。
    • 实现一个接口run()，通过该接口真正创建对应数量的新线程，并且开始执行。每成功创建一个线程且开始执行后，都要打印该线程开始运行的信息，比如thread1 start...。
    • run()创建线程需要循环_threads容器内Thread变量的start()函数，所有的线程就会启动。
    • 所有线程都执行静态handerTask函数，与以前一样，还是需要去掉this指针。
    • handler_task函数需要使用线程名和this指针，所以我们在前面创建一个ThreadData结构体存放它们，this指针放在ThreadPool* threadpool中，线程的名字放在_threadname中。创建线程就直接把这个结构体指针传过去就可以了。

    • 消费线程执行handler_task，该函数会从任务队列_task_queue中取任务执行，并且它们要按照一定顺序去访问，所以线程是同步和互斥的关系。
    • 因为handler_task是Thread类对象在执行，所以它中不能直接访问ThreadPool中的条件变量和锁。所以在类内需要提供公有的接口允许线程访问私有成员，允许其进行加锁，解锁，条件判断，以及取任务等操作。

    • 在访问任务队列的时候先加锁，如果任务队列为空则挂起等待，如果不为空则取走任务并处理任务。
    • 从任务队列中获取任务后，不再操作临界资源，所以解锁在前，任务处理在后。线程获取到任务时，会将任务放到自己的独立栈结构中。所以线程处理任务是相互独立的。
    • 线程处理完任务后，将在堆区存放当前线程属性的ThreadData对象释放掉。
    • 倒数第二步定义push函数用于推送任务，由于推送任务是操作临界资源，在推送任务到任务队列前加锁，推送完成后唤醒在条件变量_cond下等待的一个消费线程，再进行解锁。
    • 最后将从队列中取数据的pop函数定义，由于其在加锁代码里，素以不用考虑线程安全问题。

    4.运行

    此时我们再根据任务类型在main函数和handler_task函数中设置打印函数显示线程调度就可以了。我们设置主线程每一秒推送一个计算任务，计算任务直接使用之前的类。

    CalTask.hpp

    1. #include
    2. #include
    3. #include
    4. #define MAX_NUM 10
    5. //计算任务类
    6. class CalTask
    7. {
    8.     typedef std::function<int(int,int,char)> func_t;
    9. public:
    10.     //默认构造
    11.     CalTask()
    12.     {}
    13.     //构造函数
    14.     CalTask(int a, int b, char op, func_t func)
    15.         :_a(a)
    16.         ,_b(b)
    17.         ,_op(op)
    18.         ,_func(func)
    19.     {}
    20.  
    21.     //仿函数
    22.     std::string operator()()
    23.     {
    24.         int result = _func(_a, _b, _op);
    25.         char buffer[64];
    26.         snprintf(buffer, sizeof(buffer), "%d %c %d = %d", _a, _op, _b, result);
    27.         std::string s(buffer);
    28.         return s;
    29.     }
    30.  
    31.     //显示任务
    32.     std::string show_task()
    33.     {
    34.         char buffer[64];
    35.         snprintf(buffer, sizeof(buffer), "%d %c %d = ?", _a, _op, _b);
    36.         std::string s(buffer);
    37.         return s;
    38.     }
    39. private:
    40.     func_t _func;
    41.     int _a;
    42.     int _b;
    43.     char _op;
    44. };

    Thread.hpp

    1. #include
    2. #include
    3. #include
    4. #define NUM 64
    5.  
    6. class Thread
    7. {
    8.     typedef std::function<void*(void*)> func_t;
    9. public:
    10.     //构造函数创建线程
    11.     Thread()
    12.     {
    13.         //对线程进行规范化命名
    14.         char buffer[NUM];
    15.         snprintf(buffer, sizeof(buffer), "thread%d", _threadnum++);
    16.         _name = buffer;
    17.     }
    18.  
    19.     //启动线程
    20.     void start(func_t func, void* args = nullptr)
    21.     {
    22.         //初始化这两个变量
    23.         _args = args;
    24.         _func = func;
    25.         //创建线程，线程的处理函数为start_routine
    26.         int n = pthread_create(&_tid, nullptr, start_routine, (void*)this);//将this指针传递到执行代码中
    27.         //断言创建成功，这里也可以换成打印错误码的代码
    28.         assert(n == 0);
    29.     }
    30.  
    31.     //利用回调函数
    32.     void* callback()
    33.     {
    34.         return _func(_args);
    35.     }
    36.  
    37.     //获取线程的名字
    38.     std::string threadname()
    39.     {
    40.         return std::string(_name);
    41.     }
    42.  
    43.     void join()
    44.     {
    45.         int n = pthread_join(_tid, nullptr);
    46.         assert(n == 0);
    47.     }
    48. private:
    49.     //处理函数的函数能只有一个确定的参数，所以只能定义为静态。
    50.     static void* start_routine(void* args)//用args传递this指针
    51.     {
    52.         Thread* pt = static_cast(args);
    53.         return pt->callback();
    54.     }
    55.  
    56.     std::string _name;
    57.     pthread_t _tid;
    58.     func_t _func; 
    59.     void* _args;
    60.     static int _threadnum;
    61. };
    62.  
    63. int Thread::_threadnum = 1;

    Threadpool.hpp

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define THREAD_NUM 10
    6.  
    7. //前面加上声明
    8. template <class T>
    9. class ThreadPool;
    10.  
    11. //线程数据类
    12. template <class T>
    13. class ThreadData
    14. {
    15. public:
    16.     ThreadPool* _pthreadpool;//线程池的this指针
    17.     std::string _threadname;//线程的名字
    18.     //构造函数
    19.     ThreadData(ThreadPool* tp, std::string name)
    20.         :_pthreadpool(tp)
    21.         ,_threadname(name)
    22.     {}
    23. };
    24.  
    25. //线程池
    26. template <class T>
    27. class ThreadPool
    28. {
    29. public:
    30.     //构造函数
    31.     ThreadPool(int num = THREAD_NUM)
    32.     :_num(num)
    33.     {
    34.         pthread_mutex_init(&_cmutex, nullptr);//初始化消费互斥锁
    35.         pthread_mutex_init(&_pmutex, nullptr);//初始化生产互斥锁
    36.         pthread_cond_init(&_cond, nullptr);//初始化条件变量
    37.         //创建多个线程
    38.         for(size_t i = 0; i < _num; ++i)
    39.         {
    40.             _threads.push_back(new Thread());
    41.         }
    42.     }
    43.  
    44.     //析构函数
    45.     ~ThreadPool()
    46.     {
    47.         pthread_mutex_destroy(&_cmutex);//销毁消费互斥锁
    48.         pthread_mutex_destroy(&_pmutex);//销毁生产互斥锁
    49.         pthread_cond_destroy(&_cond);//销毁条件变量
    50.         //销毁多个线程
    51.         for(size_t i = 0; i < _num; ++i)
    52.         {
    53.             _threads[i]->join();
    54.             delete _threads[i];
    55.         }
    56.     }
    57.  
    58.     //将所有线程启动
    59.     void run()
    60.     {
    61.         for(size_t i = 0; i < _num; ++i)
    62.         {
    63.             //由于线程函数需要使用线程池类内的函数和每一个线程的名字，所以将它们合起来构造一个线程数据类传递给线程操作函数
    64.             ThreadData* p = new ThreadData(this, _threads[i]->threadname());
    65.             _threads[i]->start(handler_task, (void*)p);//这里也可以设计一个类
    66.             std::string s(p->_threadname);
    67.             s += " start...\n";
    68.             std::cout << s;
    69.         }
    70.     }
    71.  
    72.     //向线程池推送任务
    73.     void push(const T& data)
    74.     {
    75.         pthread_mutex_lock(&_pmutex);
    76.         _task_queue.push(data);
    77.         pthread_cond_signal(&_cond);
    78.         pthread_mutex_unlock(&_pmutex);
    79.     }
    80.  
    81.     //消费线程取任务，加锁解锁已经在消费线程处理函数里进行了，不需要注意线程安全
    82.     T pop()
    83.     {
    84.         T data = _task_queue.front();
    85.         _task_queue.pop();
    86.         return data;
    87.     }
    88.  
    89.     //静态成员函数需要访问的非静态成员接口
    90.     bool isQueueEmpty() {return _task_queue.empty();}//判断任务队列是否为空
    91.     void lockQueue() {pthread_mutex_lock(&_cmutex);}//给任务队列加锁
    92.     void unlockQueue() {pthread_mutex_unlock(&_cmutex);}//给任务队列解锁
    93.     void threadWait() {pthread_cond_wait(&_cond,&_cmutex);}//将线程放入条件变量的等待队列中
    94.  
    95. private:
    96.     //消费线程的处理函数
    97.     static void* handler_task(void* args)
    98.     {
    99.         ThreadData* p = (ThreadData*)args;
    100.         while(1)
    101.         {
    102.             p->_pthreadpool->lockQueue();
    103.             //如果任务队列为空，消费者进程会被加入到条件变量的阻塞队列中
    104.             while(p->_pthreadpool->isQueueEmpty())
    105.             {
    106.                 p->_pthreadpool->threadWait();
    107.             }
    108.             T data = p->_pthreadpool->pop();
    109.             p->_pthreadpool->unlockQueue();
    110.             printf("%s接受了任务%s并处理完成，结果为：%s\n", p->_threadname.c_str(), 
    111.             data.show_task().c_str(), data().c_str());
    112.         }
    113.         delete p;
    114.         return nullptr;
    115.     }
    116.  
    117.     int _num;//维护的线程数量
    118.     std::vector _threads;//管理多个线程对象的容器
    119.     std::queue _task_queue;//任务队列
    120.     pthread_mutex_t _cmutex;//消费者互斥锁
    121.     pthread_cond_t _cond;//条件变量
    122.     pthread_mutex_t _pmutex;//生成任务时的互斥锁
    123. };

    test.cc

    1. #include
    2. #include
    3. #include"CalTask.hpp"
    4. #include"Thread.hpp"
    5. #include"Threadpool.hpp"
    6.  
    7. using namespace std;
    8.  
    9. //计算器函数
    10. const string ops = "+-*/%";
    11. int calculate(int a, int b, char op)
    12. {
    13.     int result = 0;
    14.     switch(op)
    15.     {
    16.         case '+':
    17.             result = a + b;
    18.             break;
    19.         case '-':
    20.             result = a - b;
    21.             break;
    22.         case '*':
    23.             result = a * b;
    24.             break;
    25.         case '/':
    26.         {
    27.             if(b == 0)
    28.                 cerr << "除数不能为0\n";
    29.             else
    30.                 result = a / b;
    31.         }
    32.             break;
    33.         case '%':
    34.         {
    35.             if(b == 0)
    36.                 cerr << "取模的数字不能为0\n";
    37.             else
    38.                 result = a % b;
    39.         }
    40.             break;
    41.         default:
    42.             break;
    43.     }
    44.     return result;
    45. }
    46.  
    47. int main()
    48. {
    49.     srand((unsigned int)time(nullptr));
    50.     ThreadPool* tp = new ThreadPool();
    51.     tp->run();
    52.     for(;;)
    53.     {
    54.         //
    55.         int a = rand()%10;
    56.         int b = rand()%10;
    57.         char op = ops[rand()%ops.size()];
    58.         CalTask task(a, b, op, calculate);
    59.         tp->push(task);
    60.         printf("主线程推送任务:%d %c %d = ?\n", a, op, b);
    61.         sleep(1);
    62.     }
    63.     return 0;
    64. }

    运行结果：

    5.RAII加锁改造

    我们之前写了一个LockGuard类，我们可以将这个类在task_handler的加锁代码中就可以用起来。

    1. #include
    2. class mutex
    3. {
    4. public:
    5.     //构造函数
    6.     mutex(pthread_mutex_t* p = nullptr)
    7.         :_pmutx(p)
    8.     {}
    9.     //加锁
    10.     void lock()
    11.     {
    12.         pthread_mutex_lock(_pmutx);
    13.     }
    14.     //解锁
    15.     void unlock()
    16.     {
    17.         pthread_mutex_unlock(_pmutx);
    18.     }    
    19. private:
    20.     pthread_mutex_t* _pmutx;
    21. };
    22.  
    23. class LockGuard
    24. {
    25. public:
    26.     LockGuard(pthread_mutex_t* lock_p):_mutex(lock_p)
    27.     {
    28.         _mutex.lock();//构造函数内加锁
    29.     }
    30.     ~LockGuard()
    31.     {
    32.         _mutex.unlock();//析构函数内解锁
    33.     }
    34. private:
    35.     mutex _mutex;
    36. };

    LockGuard构造函数加锁，析构函数解锁。通过{}控制该变量的生命周控制加锁。

    由于该函数是由线程执行的，锁是线程池的私有变量，所以也需要增加一个函数获取锁。

    最后改造的handler_task代码如下：

    代码正常运行。

    二、利用单例模式改造线程池

    1.复习

    饿汉模式和懒汉模式都是单例模式的实现方式，具体的介绍可以看这篇博客的第二章：C++特殊类设计及类型转换_聪明的骑士的博客-CSDN博客

    现在我们要将线程池改为这两种单例模式。

    2.饿汉模式

    饿汉模式：不管以后会不会使用单例对象，只要程序一启动，程序就会先创建一个唯一的实例对象然后再执行其他代码。

    首先，增加一个静态对象保证单例的唯一性，静态变量需要在根据自己的类型在类外初始化。

    然后需要将构造函数设为私有，并且不允许生成拷贝构造和赋值运算符重载。

    最后，添加一个静态函数GetInstance()获取单例的地址。

    此时，更改一下主线程的代码：

    1. int main()
    2. {
    3.     srand((unsigned int)time(nullptr));
    4.     ThreadPool::GetInstance()->run();
    5.     for(;;)
    6.     {
    7.         int a = rand()%10;
    8.         int b = rand()%10;
    9.         char op = ops[rand()%ops.size()];
    10.         CalTask task(a, b, op, calculate);
    11.         ThreadPool::GetInstance()->push(task);
    12.         printf("主线程推送任务:%d %c %d = ?\n", a, op, b);
    13.         sleep(1);
    14.     }
    15.     return 0;
    16. }

    程序正常运行。

    3.懒汉模式

    懒汉模式：单例只有在第一次被使用到时才被建立，就像一个懒汉一样，什么事都拖到截止日才干。

    首先，在原来饿汉模式的基础上将单例对象改为单例对象指针，并且设置为空。

    然后，为了保证单例的建立是线程安全的，还要增加一个C++11提供的锁并在类外初始化（需要包含mutex.h头文件，这里用C++标准提供的锁是因为它操作更方便）。

    最后，使用之前的双检查加锁方式重新设计一下获取单例指针的接口。

    主线程代码不需要改，直接运行就可以跑起来了。

    最后，所有Linux系统编程的知识就讲解完毕了，接下来我们要进行网络编程的学习。

  • 相关阅读:
    【思想篇-能力】新人成长
    C++——stack和queue的使用和OJ练习题
    vue3中子级页面绑定调用父级页面得自定义事件
    RPC - gRPC简单的demo - 学习/实践
    Switch case 使用及嵌套语法
    游戏优化之空间划分
    系统数据数据和信息
    C++ 2019-2022 CSP_J 复赛试题横向维度分析(上)
    轻松入门自然语言处理系列 专题7 基于FastText的文本分类
    python 替换字符串中 windows非法字符 到对应的 全角合法字符
  • 原文地址：https://blog.csdn.net/qq_65285898/article/details/132743443