一、什么是线程池

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

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

二、线程池的优点

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

三、线程池的应用

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

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

对性能要求苛刻的应用

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

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

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

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

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

thread_pool.hpp

#pragma once        
#include <iostream>    
#include <string>    
#include <queue>    
#include <unistd.h>    
#include <pthread.h> using namespace std;namespace ns_threadpool    
{    const int g_num = 5;    template <class T>    class ThreadPool    {    private:    int num_; //固定大小的线程池   queue<T> 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<T>* tp = (ThreadPool<T>*)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 <iostream>    
#include <pthread.h>    
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 <ctime>    
#include <cstdlib> using namespace ns_threadpool;    
using namespace ns_task; int main()                                                                                                                                                                            
{    ThreadPool<Task>* tp = new ThreadPool<Task>();//创建线程池    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<T> data;//饿汉模式，在加载的时候对象就已经存在了 
public: static Singleton<T>* GetInstance() { return &data; } 
};

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

2. 懒汉实现方式

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

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

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

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

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

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

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

thread_pool.hpp

#pragma once
#include <iostream>
#include <string>
#include <queue>
#include <unistd.h>
#include <pthread.h>using namespace std;namespace ns_threadpool
{const int g_num = 5;template <class T>class ThreadPool{private:int num_;queue<T> task_queue_;pthread_mutex_t mtx_;pthread_cond_t cond_;static ThreadPool<T>* ins;//类内的静态指针private://构造函数必须得实现，必须初始化ThreadPool(int num = g_num):num_(num){pthread_mutex_init(&mtx_, nullptr);pthread_cond_init(&cond_, nullptr);}ThreadPool(const ThreadPool<T>& tp) = delete;ThreadPool<T>& operator=(ThreadPool<T>& tp) = delete;public:static ThreadPool<T>* GetInstance(){//使用静态的锁是不需要初始化和销毁的static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;if(ins == nullptr)//双判定，减少锁的征用，提高获取单例的效率{pthread_mutex_lock(&lock);if(ins == nullptr){ins = new ThreadPool<T>();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<T>* tp = (ThreadPool<T>*)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<T>* ThreadPool<T>::ins = nullptr;}

main.cc

#include "thread_pool.hpp"    
#include "Task.hpp"    
#include <ctime>    
#include <cstdlib>    
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<Task>::GetInstance()->PushTask(t);    //单列本身会在任何场景下，任何环境下被调用    //GetInstans()：被多线程重入，进而导致线程安全的问题                                                                                                                          cout << ThreadPool<Task>::GetInstance() << endl;//获取对象的地址    }    return 0;    
}

Task.hpp同上

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

六、其他常见的各种锁

悲观锁：

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

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

乐观锁：

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

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

自旋锁：

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