单例模式及其线程安全问题

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 提供了对线程安全的支持。