一文阐述设计模式单利模式的7种写法

前沿

提起单利模式，我们潜意识里会出现饱汉模式、饿汉模式、双重判断等，但是你知道单利模式其他的写法以及优缺点吗？接下来我们一一说明。

正文

单利模式的要点有几个：私有的无参构造器 +  私有静态变量 + 提供静态公有的对外方法，单利模式离不开上述3要素。

基础版

饱汉模式

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

    private Singleton() {
    }

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

静态属性，jvm保证了这个属性只会被赋值一次，但是instance属性不一定被用，但是已经被赋值，空间的浪费。

饿汉模式

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

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

instance属性只有在第一次被使用的时候，才会赋值，避免资源浪费，但是getInstance()方法在第一次高并发的情景下，可能产生的对象是多个，也就是线程不安全。

方法上加锁双重判断

public class Singleton {
    private static Singleton instance = null;

    private Singleton () {
    }

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

在方法上加synchronized 锁，保证了同一时刻只能有一个线程进入方法内，解决了线程不安全问题，但是synchronized加在方法上，使后续的请求只能窜行的访问，降低了程序的并发度。

局部加锁双重判断

public class Singleton {
    private static Singleton instance = 鞥null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

通过2次对instance的非空判断 + 通过synchronized 加锁，在代码逻辑上避免了无锁的线程不安全情况。但是synchronized 是重量级锁，虽然在1.7之后对synchronized 进行了优化。你以为这样就万无一失了吗？

首先要明白在JVM创建新的对象时，主要要经过三步。

 1、分配内存

 2、初始化构造器

3、将对象指向分配的内存的地址

这种顺序在上述双重判断的方式是没有问题的，因为这种情况下JVM是完成了整个对象的构造才将内存的地址交给了对象。但是如果发生先执行步骤3，再执行步骤2（JVM会针对字节码进行调优，而其中的一项调优便是调整指令的执行顺序），就会出现问题了。

因为将对象指向分配的内存地址后，这个对象就不为空，从而就会被其他线程拿过去使用，当在调用对象中的方法的时候，就会出现问题，因为这个对象还没有初始化构造器，还不是一个完整的对象，从而会发生异常。但是这是我们高级语言没法控制，只能交给jvm来保证。我们知道会有这个风险即可，但是发生的概率会很小很小，大家也没必要过分的担心。

既然上面使用的锁是重量级，那么下面通过轻量级锁对其改造

ReentrantLock加锁

public class Singleton{
    private static Singletoninstance = null;
    private static final ReentrantLock lock = new ReentrantLock();

    private Singleton() {
    }

    public static SingletongetInstance() {
        if (instance == null) {
            lock.lock();
            if (instance == null) {
                instance = new Singleton();
            }
            lock.unlock();
        }
        return instance;
    }
}

解决了重量级锁对资源的过度占用，又达到了线程安全的目的。

进阶版

轻量级锁，也是有资源消耗的，有没有一种写法无需加锁呢？

基于内部类的单利模式

public class Singleton {

    private Singleton() {
    }

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

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

这种方法避免了上面会出现莫名其妙的问题，类的静态属性只有在第一次加载类的时候被初始化，这是JVM帮我们保证的，所以获取到的Singleton 同一个。

我们能不能通过枚举类实现单利模式呢？

枚举类单利模式

public enum Singleton {
    INSTANCE;

    public void doMethod() {
        //具体业务实现
    }
}

写法简单，无需加锁，JVM帮我们保证了Singleton 是单利。

7种单利模式写法，你们知道了吗？如果你有更多的写法，请打在评论区