Linux —— 线程池

一、什么是线程池

二、线程池的优点

三、线程池的应用

一、什么是线程池

线程池是线程的一种使用模式。在前面的情况中，我们都是遇到任务然后创建线程再执行。但是线程的频繁创建就类似于内存的频繁申请，会给操作系统带来更大的压力，进而影响整体的性能。

所以我们一次申请好一定数量而定线程，然后将线程的管理操作交给线程池，就避免了在短时间内不断创建与销毁线程的代价，线程池不但能够保证内核的充分利用，还能防止过分调度，并根据实际业务情况进行修改。

二、线程池的优点

任务来到立马就有线程去执行任务，节省了创建线程的时间。
防止服务器线程过多导致的系统过载问题
相对于进程池，线程池资源占用较少，但是健壮性很差

三、线程池的应用

需要大量的线程来完成任务，且完成任务的时间比较短

例如：WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

对性能要求苛刻的应用

比如要求服务器迅速响应客户请求。

接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用

突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。

四、实现一个简单的线程池

线程池中提供了一个任务队列，以及若干个线程。示意图如下：

thread_pool.hpp


#pragma once        
#include     
#include     
#include     
#include     
#include  
   
using namespace std;
    
namespace ns_threadpool    
{    
    const int g_num = 5;    
    template <class T>    
    class ThreadPool    
    {    
    private:    
        int num_; //固定大小的线程池   
        queue task_queue_; //任务队列，使用STL的queue实现   
        pthread_mutex_t mtx_; //定义一把锁  
        pthread_cond_t cond_; //定义一个条件变量
   
    public:    
        void Lock() { pthread_mutex_lock(&mtx_);} //加锁操作     
    
        void Unlock() { pthread_mutex_unlock(&mtx_);} //解锁操作   
   
        bool IsEmpety() { return task_queue_.empty();} //判断任务队列是否为空  
    
        void Wait() { pthread_cond_wait(&cond_, &mtx_);} //让线程在条件变量下等待   
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
        void WakeUp() { pthread_cond_signal(&cond_);} //唤醒在条件变量下等待的线程   
   
    public:    
        ThreadPool(int num = g_num):num_(num)    
        {    
            pthread_mutex_init(&mtx_, nullptr);    
            pthread_cond_init(&cond_, nullptr);    
        }    
    
        //在类中要让线程执行类内成员方法，是不可行的    
        //必须让线程执行静态方法    
        static void* Rountine(void* args)    
        {    
            pthread_detach(pthread_self());    
            ThreadPool* tp = (ThreadPool*)args;    
            while(true)    
            {    
                tp->Lock();    
                while(tp->IsEmpety())    
                {    
                    tp->Wait();    
                }    
                T t;    
                tp->PopTask(&t);    
                tp->Unlock();    
                t.Run();    
    
            }    
        }    
    
        void InitThreadPool()    
        {    
            pthread_t tid;    
            for(int i = 0; i < num_; i++)    
            {    
                pthread_create(&tid, nullptr, Rountine, (void*)this);    
            }    
        }    
    
        void PushTask(const T& in)//向任务队列添加任务    
        {    
            Lock();    
            task_queue_.push(in);    
            Unlock();    
            WakeUp();    
        }    
    
        void PopTask(T* out)//从任务队列获取任务    
        {    
            *out = task_queue_.front();    
            task_queue_.pop();    
        }    
    
        ~ThreadPool()    
        {    
            pthread_mutex_destroy(&mtx_);    
            pthread_cond_destroy(&cond_);    
        }    
    };    
}

Task.hpp


#pragma once                                                                                                                                                                                                                                                                                                                                                                
#include     
#include     
using namespace std;    
    
namespace ns_task    
{    
    class Task    
    {    
    private:    
        int x_;    
        int y_;    
        char op_;//用来表示：+ 、- 、* 、/ 、%    
    public:    
        Task(){}    
        Task(int x, int y, char op):x_(x), y_(y), op_(op){}    
    
        string show()    
        {    
            string message = to_string(x_);    
            message += op_;    
            message += to_string(y_);    
            message += "=?";    
            return message;    
        }    
        int Run()    
        {    
            int res = 0;    
            switch(op_)    
            {    
                case '+':    
                  res = x_ + y_;    
                  break;    
                case '-':    
                  res = x_ - y_;    
                  break;    
                case '*':    
                  res = x_ * y_;    
                  break;    
                case '/':    
                  res = x_ / y_;    
                  break;    
                case '%':    
                  res = x_ % y_;    
                  break;    
                default:    
                  cout << "bug" << endl;    
                  break;    
            }    
            printf("当前任务正在被：%lu处理，处理结果为：%d %c %d = %d\n",pthread_self(), x_, op_, y_, res);     
            return res;    
        }    
    
        int operator()()    
        {    
            return Run();    
        }    
    
        ~Task(){}    
    };    
}

main.cc


#include "thread_pool.hpp"    
#include "Task.hpp"    
#include     
#include  
   
using namespace ns_threadpool;    
using namespace ns_task; 
   
int main()                                                                                                                                                                            
{    
    ThreadPool* tp = new ThreadPool();//创建线程池    
    tp->InitThreadPool();  //进行初始化  
    srand((long long)time(nullptr));//生产随机数    
    while(true) //不断向任务队列塞数据   
    {    
        Task t(rand() % 20 + 1, rand() % 10 + 1, "+-*/%"[rand() % 5]);    
        tp->PushTask(t);    
        sleep(1);    
    }    
    return 0;    
}

相关说明：

我们创建好了线程池之后，首次我们先是对其进行初始化操作；然后不断的向任务队列塞数据，由线程池中的线程去获取任务并执行相关操作；

1.任务队列（即临界资源）是会被多个执行流同时访问，因此我们需要引入互斥锁对任务队列进行保护。

2.线程池中的线程想要获取到任务队列中的任务，那么就必须要确保任务队列中有任务，所以我们还需引入条件变量来进行判断，如果队列中没有任务，线程池中的线程将会被挂起，直到任务队列中有任务后才被唤醒；

3.在thread_pool.hpp中，多线程去执行对应的方法的时候，采用的是静态成员函数，这样做的目的是解决类中存在隐藏的this指针问题，因为多线程在调用对应的函数时，该函数只有一个形参，不加static的话，那么形参个数就有两个，是不可以的；所以我们可以将this指针作为参数传递过去，就可以访问类内的成员函数了；

运行代码后一瞬间就有六个线程，其中一个是主线程，另外五个是线程池内处理任务的线程。

五、单例模式

单例（Singleton）模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例；

使用场景：

语义上只需要一个
该对象内部存在大量的空间，保存了大量的数据，如果允许该对象存在多份，或者允许发生各种拷贝，内存中存在冗余数据；

一般Singleton模式通常有三种形式:

饿汉式：吃完饭, 立刻洗碗, 这种就是饿汉方式. 因为下一顿吃的时候可以立刻拿着碗就能吃饭。
懒汉式：吃完饭, 先把碗放下, 然后下一顿饭用到这个碗了再洗碗, 就是懒汉方式。

懒汉方式最核心的思想是 "延时加载"。（例如我们之前所学过的写时拷贝）从而能够优化服务器的启动速度。

1. 饿汉实现方式

该模式在类被加载时就会实例化一个对象，具体代码如下：


template <typename T> 
class Singleton 
{ 
private:
    static Singleton data;//饿汉模式，在加载的时候对象就已经存在了 
public: 
    static Singleton* GetInstance() 
    { 
        return &data; 
    } 
};

该模式能简单快速的创建一个单例对象，而且是线程安全的(只在类加载时才会初始化，以后都不会)。但它有一个缺点，就是不管你要不要都会直接创建一个对象，会消耗一定的性能(当然很小很小，几乎可以忽略不计，所以这种模式在很多场合十分常用而且十分简单)

2. 懒汉实现方式

该模式只在你需要对象时才会生成单例对象(比如调用GetInstance方法)


template <typename T> 
class Singleton 
{ 
private:
    static Singleton* inst; //懒汉式单例，只有在调用GetInstance时才会实例化一个单例对象
public: 
    static Singleton* GetInstance() 
    { 
        if (inst == NULL) 
        { 
            inst = new Singleton(); 
        }
    return inst; 
    } 
};

看上去，这段代码没什么明显问题，但它不是线程安全的。假设当前有多个线程同时调用GetInstance（）方法，由于当前还没有对象生成，那么就会由多个线程创建多个对象。


// 懒汉模式, 线程安全 
template <typename T> 
class Singleton 
{
private: 
    static Singleton* inst; 
    static std::mutex lock; 
public: 
    static T* GetInstance() 
    { 
        if (inst == NULL) // 双重判定空指针, 降低锁冲突的概率, 提高性能 
        {                 
            lock.lock();  // 使用互斥锁, 保证多线程情况下也只调用一次 new
            if (inst == NULL) 
            { 
                inst = new T(); 
            }
            lock.unlock(); 
        }
    return inst;
    } 
};

这种形式是在懒汉方式的基础上增加的，当多个线程调用GetInstance方法时，此时类中没有对象，那么多个线程就会来到锁的位置，竞争锁。必然只能有一个线程竞争锁成功，此时再次判断有没有对象被创建（就是inst指针），如果没有就会new一个对象，如果有就会解锁，并返回已有的对象；

总的来说，这样的形式使得多个线程调用GetInstance方法时，无论成功与否，都会有返回值；

3. 单例模式实现线程池（懒汉方式）

thread_pool.hpp


#pragma once
#include 
#include 
#include 
#include 
#include 
 
using namespace std;
 
namespace ns_threadpool
{
    const int g_num = 5;
    template <class T>
    class ThreadPool
    {
    private:
        int num_;
        queue task_queue_;
        pthread_mutex_t mtx_;
        pthread_cond_t cond_;
        static ThreadPool* ins;//类内的静态指针
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
    private:
        //构造函数必须得实现，必须初始化
        ThreadPool(int num = g_num):num_(num)
        {
            pthread_mutex_init(&mtx_, nullptr);
            pthread_cond_init(&cond_, nullptr);
        }
 
        ThreadPool(const ThreadPool& tp) = delete;
 
        ThreadPool& operator=(ThreadPool& tp) = delete;
 
    public:
        static ThreadPool* GetInstance()
        {
            //使用静态的锁是不需要初始化和销毁的
            static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
            if(ins == nullptr)//双判定，减少锁的征用，提高获取单例的效率
            {
                pthread_mutex_lock(&lock);
                if(ins == nullptr)
                {
                    ins = new ThreadPool();
                    ins->InitThreadPool();
                    cout << "首次加载对象..." << endl;
                }
                pthread_mutex_unlock(&lock);
            }
            return ins;
        }
        void Lock() { pthread_mutex_lock(&mtx_);}
 
        void Unlock() { pthread_mutex_unlock(&mtx_);}
 
        bool IsEmpety(){ return task_queue_.empty();}
 
        void Wait() { pthread_cond_wait(&cond_, &mtx_);}
 
        void WakeUp() { pthread_cond_signal(&cond_);}
    public:
 
        //在类中要让线程执行类内成员方法，是不可行的
        //必须让线程执行静态方法
        static void* Rountine(void* args)
        {
            pthread_detach(pthread_self());
            ThreadPool* tp = (ThreadPool*)args;
            while(true)
            {
                tp->Lock();
                while(tp->IsEmpety())
                {
                    tp->Wait();
                }
                T t;
                tp->PopTask(&t);
                tp->Unlock();
                t.Run();
 
            }
        }
 
        void InitThreadPool()
        {
            pthread_t tid;
            for(int i = 0; i < num_; i++)
            {
                pthread_create(&tid, nullptr, Rountine, (void*)this);
            }
        }
 
        void PushTask(const T& in)
        {
            Lock();
            task_queue_.push(in);
            Unlock();
            WakeUp();
        }
 
        void PopTask(T* out)
        {
            *out = task_queue_.front();
            task_queue_.pop();
        }
 
        ~ThreadPool()
        {
            pthread_mutex_destroy(&mtx_);
            pthread_cond_destroy(&cond_);
        }
    };
 
    template<class T>
    ThreadPool* ThreadPool::ins = nullptr;
 
}

main.cc


#include "thread_pool.hpp"    
#include "Task.hpp"    
#include     
#include     
using namespace ns_threadpool;    
using namespace ns_task;    
int main()    
{    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    cout << "当前正在运行我的进程和其他代码......" << endl;    
    sleep(5);    
    srand((long long)time(nullptr));    
    while(true)    
    {    
        sleep(1);    
        Task t(rand() % 20 + 1, rand() % 10 + 1, "+-*/%"[rand() % 5]);    
        ThreadPool::GetInstance()->PushTask(t);    
        //单列本身会在任何场景下，任何环境下被调用    
        //GetInstans()：被多线程重入，进而导致线程安全的问题                                                                                                                          
        cout << ThreadPool::GetInstance() << endl;//获取对象的地址    
    }    
        return 0;    
}

Task.hpp同上

运行后发现对象的地址是一样的，表明单例调用成功了，只存在一份；

六、其他常见的各种锁

悲观锁：

        在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。

         悲观锁适用于写多读少的情况下，即：需要频繁的写数据时候，可以考虑使用悲观锁。

乐观锁：

        每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。

         乐观锁适用于读多写少的情况下，即：读数据多余写数据的时候，可以考虑使用乐观锁。

自旋锁：

        当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

相关阅读:
oracle---一表向另一表循环插入数据过程中、发现异常并抛进日志表、直至数据传输完成
 js Ajax函数封装及使用
 Python文件及目录操作（高级文件操作篇）
Java — static修饰符
 JMM对数据竞争的定义
 ASPX与ASP URL传递值问题
 Redis Lua脚本实现分布式锁
 uniapp 跳转页面保存和刷新拦截器的使用
 计算机毕业设计（附源码）python医院预约挂号系统
 人脸识别：insightface自定义数据集制作 | 附练手数据集
原文地址：https://blog.csdn.net/sjsjnsjnn/article/details/126364511