你真的学透单例模式了吗

一、概述

单例模式（Singleton Pattern）指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式

二、类图

在这里插入图片描述

三、通用写法

public class SingletonTest {

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
    }

    static class Singleton {
        private static final Singleton instance = new Singleton();

        private Singleton() {

        }

        public static Singleton getInstance() {
            return instance;
        }
    }
}

四、单例模式相关问题

4.1 饿汉式单例写法弊端

饿汉式单例写法在类加载的时候立即初始化，并且创建单例对象。

它绝对线程安全，在线程还没出现之前就实例化了，不可能存在访问安全问题。

饿汉式单例还有另外一种写法，代码如下：

public class SingletonTest {

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
    }

    static class Singleton {
        private static final Singleton instance;

        static {
            instance = new Singleton();
        }

        private Singleton() {

        }

        public static Singleton getInstance() {
            return instance;
        }
    }
}

这种写法使用静态块的机制，非常简单也容易理解。饿汉式单例写法适用于单例对象较少的情况。

这样写可以保证绝对线程安全，执行效率比较高。但是它的缺点也很明显，就是所有对象类在加载的时候就实例化。这样一来，如果系统中有大批量的单例对象存在，而且单例对象的数量也不确定，则系统初始化时会造成大量的内存浪费，从而导致系统内存不可控。

4.2 懒汉式单例写法

class LazySingleton {
    private LazySingleton() {
    }

    private static LazySingleton lazy = null;

    public static LazySingleton getInstance() {
        if (lazy == null) {
            lazy = new LazySingleton();
        }
        return lazy;
    }
}

如果两个线程在同一时间同时进入getInstance()方法，则会同时满足if(null== instance)条件，创建两个对象。如果两个线程都继续往下执行后面的代码，则有可能后执行的线程的结果覆盖先执行的线程的结果。

那么如何解决呢？

给getInstance()方法加上synchronized关键字，使这个方法变成线程同步方法即可。

class LazySingleton {
    private LazySingleton() {
    }

    private static LazySingleton lazy = null;

    public synchronized static LazySingleton getInstance() {
        if (lazy == null) {
            lazy = new LazySingleton();
        }
        return lazy;
    }
}

虽然这样能完美解决问题，但是如果在线程数量剧增的情况下，用synchronized加锁，则会导致大批线程阻塞，从而导致程序性能大幅下降。

那么我们将其改造为双重检查锁单例写法：

class LazySingleton {
    private LazySingleton() {
    }

    private static LazySingleton lazy = null;

    public static LazySingleton getInstance() {
        //检查是否要创建
        if (lazy == null) {
            synchronized (LazySingleton.class) {
                //再次检查，避免有多个线程同时进入上面的if代码块，避免指令重排序问题
                if (lazy == null) {
                    lazy = new LazySingleton();
                }
            }
        }
        return lazy;
    }
}

那么这个方案完美了吗？

其实并不，我们还可以通过反射来强行创建不同实例对象

public static void main(String[] args) {
    try {
        //通过反射获取构造方法
        Constructor constructor = LazySingleton.class.getDeclaredConstructor(null);
        //强制访问私有方法
        constructor.setAccessible(true);
        Object o1 = constructor.newInstance();
        Object o2 = constructor.newInstance();
        System.out.println(o1==o2);//结果为false，单例失效
    } catch (Exception e) {
        e.printStackTrace();
    }
}

接下来就是终极单例大法了，利用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();
    }
}

那么这真的就是终极大法了吗？其实还有骚操作.

枚举式单例写法：

public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public Object  getData(){
        return data;
    }

    public void setData(Object data){
        this.data = data;
    }

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
    
}

public static void main(String[] args) {
    EnumSingleton instance1 = EnumSingleton.getInstance();
    EnumSingleton instance2 = EnumSingleton.getInstance();
    System.out.println(instance1 == instance2); //结果为true
}