1.单例模式？
即保证对一个类只实例化一个对象，比如spring的bean
2.单例模式的组成？
包括一个私有构造器，一个私有静态变量，一个公有的静态方法
3.单例模式线程安全问题？
如何在高并发下保证 线程安全+资源消耗少
4.饿汉式(线程安全)
/**
* @Author waw
* @Date 2020/3/18 17:01
* @Version 1.0
* @Description: 饿汉式单例模式
*/
public class EagerSingle {
//私有的静态实例
private static EagerSingle eagerSingleInstance = new EagerSingle();
//私有的构造器
private EagerSingle(){}
//公有的静态方法
public static EagerSingle getEagerSingle(){
return eagerSingleInstance;
}
}
优点：线程安全的
缺点：直接实例化，资源会浪费。
丢失了延迟实例化的性能好处
5.懒汉式(线程安全)
/**
* @Author waw
* @Date 2020/3/18 17:07
* @Version 1.0
* @Description:懒汉式单例模式
*/
public class LazySingle {
//私有静态实例对象
private static LazySingle lazySingleInstance;
//私有构造器
private LazySingle(){}
//公有静态方法
public static LazySingle getLazySingle(){
if(null == lazySingleInstance){
lazySingleInstance = new LazySingle();
}
return lazySingleInstance;
}
}
优点：一开始不进行实例化
缺点：非线程安全
6.线程安全的懒汉式单例
/**
* @Author waw
* @Date 2020/3/18 17:11
* @Version 1.0
* @Description: 线程安全的懒汉式单例模式
*/
public class SychLazySingle {
//私有的静态实例
private static SychLazySingle sychLazySingleInstance;
//私有的构造器
private SychLazySingle(){}
//公有的静态方法
public synchronized static SychLazySingle getSychLazySingleInstance(){
if(null == sychLazySingleInstance){
sychLazySingleInstance = new SychLazySingle();
}
return sychLazySingleInstance;
}
}
优点:一开始不用创建实例、线程安全
缺点：高并发下多线程会存在线程阻塞问题
不推荐
7.双重校验锁
/**
* @Author waw
* @Date 2020/3/18 17:17
* @Version 1.0
* @Description: 双重校验锁
*/
public class DobSychSingle {
//私有的静态实例
private static DobSychSingle instance;
//私有构造器
private DobSychSingle(){}
//公有静态方法
public static DobSychSingle getInstance(){
if(null == instance){
synchronized (DobSychSingle.class){
if(null == instance){
instance = new DobSychSingle();
}
}
}
return instance;
}
}
优点: 一开始不用实例化、线程安全、
缺点：基本上没缺点，除了第一次实例化的时候可能会线程阻塞。
8.静态内部类实现
/**
* @Author waw
* @Date 2020/3/18 17:27
* @Version 1.0
* @Description:静态内部类实现
*/
public class StaticInerClassSingle {
//私有的静态实例
private static class innerClass{
private static final StaticInerClassSingle INSTANCE = new StaticInerClassSingle();
}
//私有构造器
private StaticInerClassSingle(){}
//公有静态方法
public static StaticInerClassSingle getInstance(){
return innerClass.INSTANCE;
}
}
内部静态类的变量不会在类加载的时候就初始化好，而是会在调用的时候才会初始化。保证了资源的节约、
具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。