0
0

【Linux】简单线程池的设计与实现 -- 单例模式

前言

线程池:
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

线程池的应用场景：

  1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
  2. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
  3. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误

线程池示例：

  • 创建固定数量线程池，循环从任务队列中获取任务对象
  • 获取到任务对象后，执行任务对象中的任务接口

对锁的封装

整体代码

LockGuard.hpp

#pragmaonce#include<iostream>#include<pthread.h>classMutex{public:Mutex(pthread_mutex_t *lock_p =nullptr):lock_p_(lock_p){}voidlock(){if(lock_p_)pthread_mutex_lock(lock_p_);}voidunlock(){if(lock_p_)pthread_mutex_unlock(lock_p_);}~Mutex(){}private:
    pthread_mutex_t *lock_p_;};classLockGuard{public:LockGuard(pthread_mutex_t *mutex):mutex_(mutex){
        mutex_.lock();// 在构造函数中进行加锁}~LockGuard(){
        mutex_.unlock();// 在析构函数中进行解锁}private:
    Mutex mutex_;};

LockGuard - RALL

对锁的封装

classLockGuard{public:LockGuard(pthread_mutex_t *mutex):mutex_(mutex){
        mutex_.lock();// 在构造函数中进行加锁}~LockGuard(){
        mutex_.unlock();// 在析构函数中进行解锁}private:
    Mutex mutex_;};

定义了一个名为 

LockGuard

的类，它实现了 RAII（Resource Acquisition Is Initialization）技术，用于自动加锁和解锁互斥量。

具体来说，

LockGuard

类的构造函数接受一个指向 

pthread_mutex_t

类型的指针作为参数，并在函数内部将该指针封装成一个 

Mutex

对象并进行加锁操作。在 

LockGuard

对象创建时，该互斥量将被自动加锁，确保线程安全。

LockGuard

类的析构函数在对象销毁时自动调用，并在函数内部对互斥量进行解锁操作。在 

LockGuard

对象销毁时，该互斥量将被自动解锁，释放锁资源。

通过使用 

LockGuard

类，可以避免手动加锁和解锁互斥量，从而减少代码出错的可能性，并确保线程安全。同时，使用 

RAII

机制可以提高代码的可读性和可维护性，使得程序更加健壮和可靠。

RALL

RAII（Resource Acquisition Is Initialization）技术是一种 C++ 语言的编程技术，它的基本思想是：在对象的构造函数中获取资源，在对象的析构函数中释放资源，从而实现资源的自动管理。

RAII 技术通常用于管理资源对象，例如内存、文件句柄、互斥锁、临界区等等，这些资源需要在使用完成后手动释放，否则会导致资源泄露或者资源使用冲突等问题。

使用 RAII 技术，可以避免手动管理资源带来的繁琐和容易出错的问题。RAII 技术的关键是利用对象的构造函数和析构函数来自动管理资源，当对象超出作用域时，其析构函数自动被调用，从而释放资源。

在 C++ 中，STL 中的智能指针和标准库中的各种容器，例如 vector、map、set等都是使用 RAII 技术实现的，它们可以自动管理内存和容器元素的生命周期，从而避免了手动管理资源的繁琐和容易出错的问题。

Mutex封装

定义了一个名为 

Mutex

的类，它封装了 

pthread_mutex_t

互斥量，并提供了 

lock()

和 

unlock()

成员函数，用于加锁和解锁互斥量

#pragmaonce#include<iostream>#include<pthread.h>classMutex{public:Mutex(pthread_mutex_t *lock_p =nullptr):lock_p_(lock_p){}voidlock(){if(lock_p_)pthread_mutex_lock(lock_p_);}voidunlock(){if(lock_p_)pthread_mutex_unlock(lock_p_);}~Mutex(){}private:
    pthread_mutex_t *lock_p_;};

Mutex

类的构造函数接受一个指向 

pthread_mutex_t

类型的指针作为参数，并在函数内部将该指针保存到成员变量 

lock_p_

中。如果构造函数没有接收到任何参数，则将 

lock_p_

初始化为 

nullptr

Mutex

类的 

lock()

成员函数用于加锁互斥量。它首先检查 

lock_p_

是否为 

nullptr

，如果不是，则调用 

pthread_mutex_lock()

函数对互斥量进行加锁操作。

Mutex

类的 

unlock()

成员函数用于解锁互斥量。它首先检查 

lock_p_

是否为 

nullptr

，如果不是，则调用 

pthread_mutex_unlock()

函数对互斥量进行解锁操作。

通过使用 Mutex 类，可以封装 pthread_mutex_t 互斥量，并提供了方便的 lock() 和 unlock() 成员函数，用于加锁和解锁互斥量。这使得代码更加简洁和易于管理，并确保线程安全。同时，Mutex 类的实现也符合 RAII 技术，可以自动释放锁资源，从而减少代码出错的可能性。

对线程创建的封装

整体代码

Thread.hpp

#pragmaonce#include<iostream>#include<string>#include<cstring>#include<cassert>#include<functional>#include<pthread.h>namespace ThreadNs
{typedef std::function<void*(void*)> func_t;constint num =1024;classThread{private:staticvoid*start_routine(void*args)// 类内成员，有缺省参数！{
            Thread *_this =static_cast<Thread *>(args);return _this->callback();}public:Thread(){char namebuffer[num];snprintf(namebuffer,sizeof namebuffer,"thread-%d", threadnum++);
            name_ = namebuffer;}voidstart(func_t func,void*args =nullptr){
            func_ = func;
            args_ = args;int n =pthread_create(&tid_,nullptr, start_routine,this);assert(n ==0);(void)n;}voidjoin(){int n =pthread_join(tid_,nullptr);assert(n ==0);(void)n;}
        std::string threadname(){return name_;}~Thread(){// do nothing}void*callback(){returnfunc_(args_);}private:
        std::string name_;// 线程名字
        func_t func_;// 任务处理函数void*args_;// 任务处理函数的参数
        pthread_t tid_;// 线程的 IDstaticint threadnum;// 计算线程个数，用于格式化线程名字为其增加编号};int Thread::threadnum =1;}

成员函数解释声明

typedef std::function<void*(void*)> func_t;

定义了一个名为 

func_t

的类型别名，它是一个函数对象类型，用于封装一个可调用对象，接受一个指针参数并返回一个指针值

staticvoid*start_routine(void*args)// 类内成员，有缺省参数！{
    Thread *_this =static_cast<Thread *>(args);return _this->callback();}

在类内创建线程，想让线程执行对应的方法，需要将方法设置成为

static

作用是创建并初始化线程
Thread(){char namebuffer[num];snprintf(namebuffer,sizeof namebuffer,"thread-%d", threadnum++);
    name_ = namebuffer;}

**构造函数

Thread()

**，它的作用是创建并初始化线程
定义了一个字符数组 

namebuffer

，用来存储线程的名称。然后，使用 

snprintf

函数将线程的名称格式化成字符串，并将该字符串存储在 

namebuffer

中。其中，

threadnum

是一个静态变量，用来记录已经创建的线程数量，每次创建线程时都会将 

threadnum 加 1

，从而保证每个线程都有一个唯一的名称

启动一个新的线程并开始执行指定的任务处理函数
voidstart(func_t func,void*args =nullptr){
    func_ = func;
    args_ = args;// 调用 pthread_create() 函数创建一个新的线程，并将线程 ID 保存到成员变量 tid_ 中int n =pthread_create(&tid_,nullptr, start_routine,this);// TODOassert(n ==0);(void)n;}

定义了 

Thread

类的成员函数 

start()

，它的作用是启动一个新的线程并开始执行指定的任务处理函数。一个任务处理函数指针 

func

和一个可选的参数 

args

，表示任务处理函数的参数。

等待线程执行结束并回收线程资源。
voidjoin(){int n =pthread_join(tid_,nullptr);assert(n ==0);(void)n;}

业务处理封装-加减乘除（可有可无）

整体代码

Task.hpp

#pragmaonce#include<iostream>#include<string>#include<cstdio>#include<functional>classTask{using func_t = std::function<int(int,int,char)>;public:Task(){}Task(int x,int y,char op, func_t func):_x(x),_y(y),_op(op),_callback(func){}
    std::string operator()(){int result =_callback(_x, _y, _op);char buffer[1024];snprintf(buffer,sizeof buffer,"%d %c %d = %d", _x, _op, _y, result);return buffer;}
    std::string toTaskString(){char buffer[1024];snprintf(buffer,sizeof buffer,"%d %c %d = ?", _x, _op, _y);return buffer;}private:int _x;int _y;char _op;
    func_t _callback;};const std::string oper ="+-*/%";intmymath(int x,int y,char op){int result =0;switch(op){case'+':
        result = x + y;break;case'-':
        result = x - y;break;case'*':
        result = x * y;break;case'/':{if(y ==0){
            std::cerr <<"div zero error!"<< std::endl;
            result =-1;}else
            result = x / y;}break;case'%':{if(y ==0){
            std::cerr <<"mod zero error!"<< std::endl;
            result =-1;}else
            result = x % y;}break;default:// do nothingbreak;}return result;}

成员函数解释声明

using func_t = std::function<int(int,int,char)>;

一个函数对象类型，用于封装一个可调用对象，接受两个 

int

类型参数和一个 

char

类型参数，并返回一个 

int

类型值。

具体来说，

func_t

是一个 

std::function

模板类的实例化类型，它接受一个函数类型作为模板参数，其中该函数类型接受两个 int 类型参数和一个 char 类型参数，分别表示运算符两侧的操作数和运算符本身，并返回一个 int 类型值，表示运算结果。

因此，func_t 类型可以用于封装一个可调用对象，该对象接受两个 int 类型参数和一个 char 类型参数，并返回一个 int 类型值，类似于 C 语言中的函数指针类型。

在本例中，

func_t

类型被用作 

Task

类的成员变量 

_callback

的类型，它用于封装一个计算加减乘除的回调函数，该函数接受两个 int 类型参数和一个 char 类型参数，并返回一个 int 类型值。在 Task 类的成员函数中，可以通过调用成员变量 _callback 来调用回调函数，并传递参数。

它的作用是执行一个回调函数，并将结果以字符串的形式返回。
std::string operator()(){int result =_callback(_x, _y, _op);char buffer[1024];snprintf(buffer,sizeof buffer,"%d %c %d = %d", _x, _op, _y, result);return buffer;}

定义了一个函数调用运算符的重载函数 

operator()

调用成员变量 

_callback

所指向的回调函数，传递成员变量 

_x、_y、_op

作为参数，并将返回值存储在 

result

变量中。使用 

snprintf

函数将计算结果格式化为一个字符串，并将其存储在 

buffer

数组中。最后，它将 

buffer

数组转换为一个 

std::string

对象，并返回该对象。

作用是将任务的信息格式化成字符串并返回。
std::string toTaskString(){char buffer[1024];snprintf(buffer,sizeof buffer,"%d %c %d = ?", _x, _op, _y);return buffer;}

使用了 C 标准库中的 

sprintf

函数将 

_x、_op 、_y

这三个成员变量格式化成字符串，并将结果存储在字符数组 

buffer

中。其中，

_x 、_y

分别表示任务要操作的两个数，

_op

表示操作符（例如加号、减号等）。然后，通过 

std::string

类型的构造函数将字符数组 

buffer

转换成字符串，并将该字符串作为函数的返回值。

线程池的设计与实现

整体代码

ThreadPool.hpp

#pragmaonce#include"Thread.hpp"#include"LockGuard.hpp"#include<vector>#include<queue>#include<mutex>#include<pthread.h>#include<unistd.h>usingnamespace ThreadNs;constint gnum =3;template<classT>classThreadPool;template<classT>classThreadData{public:
    ThreadPool<T>*threadpool;
    std::string name;public:ThreadData(ThreadPool<T>*tp,const std::string &n):threadpool(tp),name(n){}};template<classT>classThreadPool{private:staticvoid*handlerTask(void*args){
        ThreadData<T>*td =(ThreadData<T>*)args;while(true){
            T t;{
                LockGuard lockguard(td->threadpool->mutex());while(td->threadpool->isQueueEmpty()){
                    td->threadpool->threadWait();}

                t = td->threadpool->pop();}
            std::cout << td->name <<" 获取了一个任务： "<< t.toTaskString()<<" 并处理完成，结果是："<<t()<< std::endl;}delete td;// 删除new出的对象returnnullptr;}ThreadPool(constint&num = gnum):_num(num){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);for(int i =0; i < _num; i++){
            _threads.push_back(newThread());}}voidoperator=(const ThreadPool &)=delete;ThreadPool(const ThreadPool &)=delete;public:voidlockQueue(){pthread_mutex_lock(&_mutex);}voidunlockQueue(){pthread_mutex_unlock(&_mutex);}boolisQueueEmpty(){return _task_queue.empty();}voidthreadWait(){pthread_cond_wait(&_cond,&_mutex);}
    T pop(){
        T t = _task_queue.front();
        _task_queue.pop();return t;}
    pthread_mutex_t *mutex(){return&_mutex;}public:voidrun(){for(constauto&t : _threads){
            ThreadData<T>*td =newThreadData<T>(this, t->threadname());
            t->start(handlerTask, td);
            std::cout << t->threadname()<<" start ..."<< std::endl;}}voidpush(const T &in){
        LockGuard lockguard(&_mutex); 
        _task_queue.push(in);pthread_cond_signal(&_cond);}// 析构函数~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);for(constauto&t : _threads)delete t;}static ThreadPool<T>*getInstance(){if(nullptr== tp){
            _singlock.lock();if(nullptr== tp){
                tp =newThreadPool<T>();}
            _singlock.unlock();}return tp;}private:int _num;
    std::vector<Thread *> _threads;// 存放创建的线程实例的指针
    std::queue<T> _task_queue;// 存储待执行的任务。它是一个先进先出（FIFO）的队列
    pthread_mutex_t _mutex;// pthread 库中的互斥锁类型，用于保护任务队列的访问
    pthread_cond_t _cond;// pthread 库中的条件变量类型，用于线程之间的同步和通信。// 在任务队列为空时，线程需要等待条件变量的信号，以便在有新的任务加入时立即处理。// 而当任务加入队列时，需要发送条件变量的信号，以通知等待的线程有新的任务可以处理了。// tp 是一个指向 ThreadPool 类的指针，它是静态变量，只有一个实例，用于在整个程序中共享线程池的实例。// 由于线程池是一个全局的资源，需要确保所有的线程都共享同一个实例，避免资源浪费和线程安全问题。static ThreadPool<T>*tp;// 指向 ThreadPool 类的指针 tp// 由于线程池是一个单例模式，需要确保只有一个实例被创建，避免资源浪费和线程安全问题。因此，当多个线程同时访问时，// 需要使用互斥锁对其进行保护，避免多个线程同时创建线程池实例static std::mutex _singlock;// std::mutex 类型的互斥锁 _singlock。语言层面};// tp 是一个指向 ThreadPool 类对象的指针，初始值为 nullptr。// 它被用于实现 ThreadPool 类的单例模式，确保每个程序只有一个 ThreadPool 类对象。template<classT>
ThreadPool<T>*ThreadPool<T>::tp =nullptr;// _singlock 是一个互斥量，用于保护对静态成员变量 tp 的访问。// 它被用于实现线程安全的单例模式，避免多个线程同时创建 ThreadPool 类对象，导致资源浪费和线程安全问题。template<classT>
std::mutex ThreadPool<T>::_singlock;

成员函数解释声明

template<classT>classThreadData{public:
    ThreadPool<T>*threadpool;
    std::string name;public:ThreadData(ThreadPool<T>*tp,const std::string &n):threadpool(tp),name(n){}};

定义了一个名为

ThreadData

的模板类，用于封装线程池和线程之间的关系，保存了线程池的指针和线程的名称。

一个指向线程池的指针 

threadpool

，一个表示线程名称的字符串 

name

。它们分别用于保存线程池的指针和线程的名称。

接受两个参数，分别是**线程池的指针 

tp

和线程的名称 

n

。构造函数将这两个参数保存到 

ThreadData

对象的成员变量中，以便在后续的线程处理函数中使用。**

**通过创建一个 

ThreadData<T>

类型的对象，并将线程池的指针和线程的名称传递给其构造函数，可以封装线程池和线程之间的关系，并确保线程池的正确运行。在启动线程时，会将该对象的指针传递给线程，并在处理任务时使用其中的线程池指针。这样可以简化线程池的实现，提高线程池的可维护性和可扩展性。**

作为线程的入口函数，循环从任务队列中获取任务并执行。

staticvoid*handlerTask(void*args){
        ThreadData<T>*td =(ThreadData<T>*)args;while(true){//定义一个类型为 T 的变量 t，用来存储从任务队列中获取到的任务。
            T t;{
                LockGuard lockguard(td->threadpool->mutex());while(td->threadpool->isQueueEmpty()){
                    td->threadpool->threadWait();}
                t = td->threadpool->pop();}// 格式化输出信息
            std::cout << td->name <<" 获取了一个任务： "<< t.toTaskString()<<" 并处理完成，结果是："<<t()<< std::endl;}delete td;// 删除new出的对象returnnullptr;}
  • LockGuard lockguard(td->threadpool->mutex()); 这段代码使用了 RAII（Resource Acquisition Is Initialization）技术，通过定义一个局部变量 LockGuard 对象 lockguard，实现了自动获取和释放互斥锁的操作。LockGuard 是一个 RAII类模板，它的构造函数会在对象创建时获取互斥锁，析构函数会在对象销毁时释放互斥锁。这样，在函数执行过程中，只需要将需要保护的代码块放在 LockGuard 对象的作用域内，就可以保证在退出作用域时自动释放互斥锁，避免了手动释放锁的繁琐操作和可能的遗漏。 在这段代码中，LockGuard 对象 lockguard 的构造函数被调用时，传入了一个指向互斥锁的指针 td->threadpool->mutex()，表示获取该互斥锁。当 lockguard 对象的作用域结束时，析构函数自动释放该互斥锁，这样就保证了在访问任务队列时的线程安全。
  • while (td->threadpool->isQueueEmpty()) 从任务队列中获取任务并执行，它的核心是一个循环，不断尝试从任务队列中获取任务，直到获取到任务为止。
  • td->threadpool->threadWait(); 将当前线程挂起，等待有新的任务加入队列或者线程被停止。如果队列不为空，则执行下一步操作。
  • t = td->threadpool->pop(); 从任务队列中取出一个任务，并将其赋值给变量 t。这个 pop 方法的本质是将任务从公共队列中拿到，当前线程自己独立的栈中，以避免多个线程同时访问同一个任务对象的线程安全问题。
ThreadPool(constint&num = gnum):_num(num){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);for(int i =0; i < _num; i++){
        _threads.push_back(newThread());}}

**

ThreadPool

构造函数，它的作用是创建并初始化线程池**。接受一个 

int

类型的参数

num

，用来指定线程池中线程的数量。如果没有传入 num，就使用全局变量 gnum 的默认值。然后，构造函数初始化了线程池中的互斥量和条件变量，以及线程池的大小。

使用 

pthread_mutex_init

函数初始化互斥量 

_mutex

，使用 

pthread_cond_init

函数初始化条件变量 

_cond

，这两个函数都是 POSIX 线程库中的函数，用来创建和初始化互斥量和条件变量。

使用一个 

for

循环创建线程池中的线程。**每次循环创建一个 

Thread

类的实例，并将其指针添加到线程池的 

_threads

向量中**。这个 

_threads

向量是用来存储线程池中所有线程的指针的，它的大小就是线程池的大小，即 

num

。

voidoperator=(const ThreadPool &)=delete;ThreadPool(const ThreadPool &)=delete;

定义了 

ThreadPool

类的拷贝赋值运算符和拷贝构造函数，并将它们声明为 

delete

，表示禁止进行拷贝构造和拷贝赋值操作。

因为线程池是一个资源管理类，它包含了多个线程、任务队列、互斥锁、条件变量等资源，这些资源的管理和释放都需要仔细考虑。如果允许进行拷贝构造和拷贝赋值操作，就会导致多个对象共享同一份资源，可能会引起资源泄露、线程安全问题等等。

为了避免这种情况，通常会将拷贝构造函数和拷贝赋值运算符声明为 delete，表示禁止进行拷贝操作。这样，就可以确保每个线程池都拥有自己独立的资源，避免了资源共享带来的问题。需要注意的是，这段代码中使用了 C++11 中的新特性，即使用 “= delete” 显式声明某个函数为删除函数。这种方式可以在编译期间检查是否存在拷贝构造和拷贝赋值操作，避免了在运行时出现错误。

voidlockQueue(){pthread_mutex_lock(&_mutex);}

使用 

pthread_mutex_lock

函数对任务队列的互斥锁进行加锁操作，以保证在多个线程同时访问时不会出现冲突。

voidunlockQueue(){pthread_mutex_unlock(&_mutex);}

使用 

pthread_mutex_unlock

函数对任务队列的互斥锁进行解锁操作，以释放资源并让其它线程获得访问权限。

boolisQueueEmpty(){return _task_queue.empty();}

用于判断任务队列是否为空，它返回一个 bool 类型的值，如果任务队列为空则返回 true，否则返回 false。

voidthreadWait(){pthread_cond_wait(&_cond,&_mutex);}

使用 

pthread_cond_wait

函数将线程放入等待状态，并等待条件变量的信号。该函数将在 

_cond

条件变量上等待，并同时释放 

_mutex

互斥锁，以便其它线程可以获得访问权限。当条件变量的信号发生时，该函数将重新获得 

_mutex

互斥锁，并继续执行后续的任务处理操作。

将队列中的任务弹出，并返回弹出值
T pop(){
    T t = _task_queue.front();
    _task_queue.pop();return t;}

返回一个指向线程池的互斥锁的指针。
pthread_mutex_t *mutex(){return&_mutex;}

返回互斥锁的指针可以使得其它函数可以方便地对互斥锁进行加锁和解锁操作，以保证线程安全。同时，通过返回指针的方式，也避免了多余的复制操作和内存开销。

启动线程池中的所有线程，并开始处理任务。
voidrun(){for(constauto&t : _threads){
        ThreadData<T>*td =newThreadData<T>(this, t->threadname());
        t->start(handlerTask, td);
        std::cout << t->threadname()<<" start ..."<< std::endl;}}

run()

函数遍历线程池中的所有线程，并为每个线程创建一个 

ThreadData<T>

类型的对象 td。

ThreadData<T>

类型是一个模板类，用于封装线程池和线程的关系，保存了线程池的指针和线程的名称

定义了 ThreadPool 类的成员函数 push()，它的作用是向线程池中添加一个任务。
voidpush(const T &in){
    LockGuard lockguard(&_mutex);// 使用 LockGuard 对象对互斥量进行加锁 RALL设计
    _task_queue.push(in);// 进队列push// 使用 pthread_cond_signal() 函数发送一个条件信号，以通知等待在条件变量 _cond 上的线程有新的任务可以处理。pthread_cond_signal(&_cond);}

作用是获取 ThreadPool 类的单例对象。
static ThreadPool<T>*getInstance(){if(nullptr== tp){
        _singlock.lock();if(nullptr== tp){
            tp =newThreadPool<T>();}
        _singlock.unlock();}return tp;}

getInstance()

函数首先检查静态成员变量 

tp

是否为空指针。如果 

tp

不为空，直接返回 

tp

指向的对象。否则，它使用单例模式的方式创建一个新的 

ThreadPool

对象，并将其赋值给 

tp

。在创建对象时，使用了双重检查锁定的方式来确保线程安全。最后，

getInstance()

函数返回 tp 指向的对象。

调用 getInstance() 函数，可以获取 ThreadPool 类的单例对象。这使得线程池可以全局共享，并确保线程池的唯一性。通过使用单例模式，可以简化线程池的实现，提高代码的可维护性和可扩展性。

展示

main.cc

#include"ThreadPool.hpp"#include"Task.hpp"#include<memory>#include<unistd.h>intmain(){// 调用了 ThreadPool<Task> 类的静态成员函数 getInstance() 和成员函数 run()，// 用于获取 ThreadPool 类的单例对象并运行线程池// getInstance() 函数返回一个指向 ThreadPool<Task> 类对象的指针，// 该对象是全局唯一的，并使用了双重检查锁定的方式确保线程安全。然后，调用该对象的成员函数 run()，用于启动线程池的运行ThreadPool<Task>::getInstance()->run();int x, y;char op;while(1){
        std::cout <<"请输入数据1# ";
        std::cin >> x;
        std::cout <<"请输入数据2# ";
        std::cin >> y;
        std::cout <<"请输入你要进行的运算#";
        std::cin >> op;
        Task t(x, y, op, mymath);ThreadPool<Task>::getInstance()->push(t);sleep(1);}}

在这里插入图片描述

如有错误或者不清楚的地方欢迎私信或者评论指出🚀🚀

标签： linux 单例模式 运维
本文转载自: https://blog.csdn.net/DEXTERFUTIAN/article/details/132220268
版权归原作者 侠客cheems 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Linux】简单线程池的设计与实现 -- 单例模式”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航