线程池 线程安全的单例模式 饿汉方式 懒汉方式

线程池：

第一个线程安全任务队列+提前创建好最大数据上限的工作线程；
针对大量数据请求处理的场景；

好处：

1.避免大量线程频繁创建与销毁带来的时间成本；
2.任务节点以及线程有上限，避免资源耗尽的风险；

核心线程将需要处理的数据，以及数据处理的方法组织成一个任务，放入线程池，线程池只需要取出一个任务节点，通过其中的方法处理节点中的数据；
ThreadTask{要处理的数据，数据处理的方法}
ThreadPool{创建线程，创建线程安全的任务队列}

typedef void(*handler_t)(int data);
class ThreadTask{//任务类
    int _data;//要处理的数据；
    handle_t _handler;//处理数据的方法
public：
    ThreadTask(int data,handler_t handler);
    void Run(){
        return _handler(_data);}    
};//任务节点类，线程池中的线程获取到任务节点只需要调用Run
class ThreadPool{
    int _thr_num;//线程的数量
    BlockQueue _queue;//线程安全的任务队列
    void *thr_entry(void *arg){
        ThreadTask data;
        _queue.pop(&data);
        data.Run();
    }
    public:
        Init(int ,q,int mt);//初始化以及线程创建；
        TaskPush(ThreadTask &task);//任务队列；
};

线程安全的单例模式：

单例模式：非常典型的一种设计模式；
应用场景：一个类型只能实例化一个对象，一份资源只能被加载一次；
实现：饿汉方式/懒汉方式
    饿汉方式：资源在程序初始化阶段就完成加载———以空间换时间；
    懒汉方式：资源在使用的时候再去加载——延迟加载；

// 饿汉方式

## // 饿汉方式

class singleton{
private:
    static int _data;
    singleton(){}
public:
    int* getInstance(){
        return &_data;
    }

};
//1.静态修饰资源
    保证资源只有一份，并且在程序吃初始化阶段完成初始化加载；
//构造函数私有化
    实现一个类只能实例化一个对象；

//懒汉方式:延迟加载

//懒汉方式:延迟加载
class singleLeton{
private:
    volatile static T* _data;
    static std::mutex _mutex;
public:
    volatile static T* getInstance(){
    if(_data==NULL){
        _mutex.lock()
        if(_data==NULL){
        _data=new T();
        }
    _mutex.unlock();
    return _data;
    }
}
};
//1.定义对象指针；
//2.静态修饰；
//3.volatile修饰
//4.加锁保护--线程安全；
//5.二次检测--提高效率；
//6.构造函数私有化；

STL/智能指针 线程安全

STL中的容器都是非线程安全的；
智能指针：都是线程安全的或者说不涉及线程安全问题；
https://blog.csdn.net/weixin_52270223/article/details/116208230请添加链接描述

线程池 线程安全的单例模式 饿汉方式 懒汉方式

原文：https://blog.51cto.com/u_14982125/2754190