Java设计模式学习笔记：单例模式（一）

今天学到单例模式，对几种单例模式的特点做了一次梳理，从线程安全性和性能两个方面来说。

首先都知道有两种最常见的单例模式：饿汉式和懒汉式，如下：

饿汉式：

public class Hangry() {
    
    private Hangry(){};
    
    private static final Hangry instance = new Hangry();

    public static Hangry getInstance() {
        return instance;
    }

}

懒汉式：

public class Lazy() {
    
    private Lazy(){};
    
    private static final Lazy instance;

    public static Lazy getInstance() {
        if(instance == null) {
            instance = new Lazy();
        }
        return instance;
    }

}

饿汉式在类加载时，就会初始化实例，后续调用的肯定都是一个实例，绝对是线程安全的，但是这样会存在资源浪费，占用内存。

懒汉式是在调用时才初始化，这样会有一个问题就是，在高并发的情况下，可能会调用多次实例化的方法，导致对象进行了多次实例化，破坏了单例，要解决这个问题，有一个方法，就是在获取实例的方法上加一个synchronized修饰词，就能阻止前面提到的线程安全问题，代码如下：

public class Lazy() {
    
    private Lazy(){};
    
    private static final Lazy instance;

    public static synchronized  Lazy getInstance() {
        if(instance == null) {
            instance = new Lazy();
        }
        return instance;
    }

}

但是这样又会产生一个新的问题，那就是性能问题，加了synchronized会比没加synchronized时，性能慢很多倍。但是没关系，只要思想不滑坡，方法总比困难多，这个问题也能解决，思路就是使用内部类，内部类只有在外部类被调用时，才会被加载，代码如下：

public class Lazy() {
    
    private Lazy(){};

    public static synchronized Lazy getInstance() {
        
        return LazyHolder.lazy;
    }

    private static class LazyHolder {
        private static final Lazy lazy = new Lazy();
    }
}