2_单列模式_懒汉式单例模式

二.懒汉式单例模式

(1) 饿汉式单例模式概念

为了解决饿汉式单例可能带来的内存浪费问题，于是就出现了懒汉式单例的写法。懒汉式单例模式的特点是，单例对象要在被使用时才会初始化。

(2) 代码实现

实现代码方式1：简单的饿汉式单例

/**
 * 优点：节省了内存,线程安全
 * 缺点：性能低,反射破坏,序列化破坏单例 (当有1万线程访问的时候，都会排队等待每个线程执行完才进行下一个线程执行。因为添加了synchronized锁)
 */
public class LazySimpleSingletion {
    private static LazySimpleSingletion instance;
    private LazySimpleSingletion(){}
    public synchronized static LazySimpleSingletion getInstance(){
        if(instance == null){
            instance = new LazySimpleSingletion();
        }
        return instance;
    }
}

实现代码方式2：添加双重检查

/**
 * 优点:性能高了，线程安全了
 * 缺点：可读性难度加大，不够优雅, 反射破坏, 序列化破坏单例
 */
public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton(){}
    public static LazyDoubleCheckSingleton getInstance(){
        //检查是否要阻塞
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //检查是否要重新创建实例
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                    //指令重排序的问题，需要加volatile关键字线程可见性。
                }
            }
        }
        return instance;
    }
}

实现代码方式3：静态类内部类实现

/*
   优点：写法优雅，利用了Java本身语法特点，性能高，避免了内存浪费,不能被反射破坏
   缺点：可读性难度加大,不优雅,序列化破坏单例
 */
public class LazyStaticInnerClassSingleton {
    private LazyStaticInnerClassSingleton(){
        if(LazyHolder.INSTANCE != null){
            throw new RuntimeException("不允许非法访问");
        }
    }
    private static LazyStaticInnerClassSingleton getInstance(){
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder{
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }
}

(3)使用场景

懒汉式单例模式的特点是，单例对象要在被使用时才会初始化。

当项目中出现大量单列对象时候，这个样就会节省内存空间。

(4)有缺点

优点：节省了内存,线程安全
缺点：性能低,反射破坏,序列化破坏单例 (当有1万线程访问的时候，都会排队等待每个线程执行完才进行下一个线程执行。因为添加了synchronized锁)

---

优点:性能高了，线程安全了
缺点：可读性难度加大，不够优雅, 反射破坏, 序列化破坏单例

---

优点：写法优雅，利用了Java本身语法特点，性能高，避免了内存浪费,不能被反射破坏
缺点：可读性难度加大,不优雅,序列化破坏单例