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

线程池：

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

好处：

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中的容器都是非线程安全的；
智能指针：都是线程安全的或者说不涉及线程安全问题；