单例模式案例总结

23种设计模式 _ 单例模式

     单例模式是我们最常遇到的设计模式之一，对于Java程序员来说，对于单例模式是十分常见了。

因为在spring的框架中，大量的单例模式设计思想被应用。

下面我们来看一下单例模式的几种实现方法：

单例模式连接

根据上面的代码我们可以看到，实现单例模式的方式十分多，

其中最经典的莫过于饿汉式和懒汉式，这两种方式其实在单线程下已经可以基本可以满足开发的需求了。

但是在多线程环境下，我们就要考虑到线程的安全问题：即是否有不同的线程分别new一个对象实例，导致

不同线程创建的class类的实例不是同一个。

 

饿汉式

通过代码我们可以知道饿汉式已经是一个非常好的一种解决方式了。

因为根据JVM原来可以，class类在被加载到内存的jvm虚拟机中，只会初始化一次静态变量。

这就在jvm层面保证class的实例只会有一个。

因为在class类加载到jvm时，class类的静态变量就已经初始化了；

所以在运行过程中，Mgr01类的INSTANCE已经被初始化，所以不论有多少线程通过getInstance方法来获取实例，都是静态变量初始化到jvm中的那一个

但是饿汉式的缺点也是这样产生的，因为在class类加载到jvm时，class类的静态变量INSTACNE就已经初始化。

所以在java的运行状态下，如果你不使用，这就造成了资源浪费。

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01(){

    }

    public static Mgr01 getInstance(){
        return INSTANCE;
    }

    public void m(){
        System.out.println("");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

懒汉式

懒汉式主要是解决饿汉式的资源浪费问题，但是这也造成了在多线程环境下，线程的安全问题：即可能new了多个Mgr03类的实例变量。

因为在INSTANCE == null时，就new Mgr03()

但是会出现一个状态，在线程较多的时候，多个线程同时运行到代码的这个位置，那么他们就会同时进入代码块，new Mgr03实例变量，

这就导致不同线程得到的INSTANCE可能不一样。

public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03(){

    }
    public static Mgr03 getInstance(){
        if(INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
/*        Mgr03 m1 = Mgr03.getInstance();
        Mgr03 m2 = Mgr03.getInstance();
        System.out.println(m1 == m2);*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr03.getInstance().hashCode());
            }).start();
        }
    }
}

Double Check Lock(DCL):

为了解决懒汉式多个线程同时进入INSTANCE == null的代码块，导致new了多个类的实例变量

一个新的方法被提出，使用synchronize加锁，以此来保证多线程下的线程安全问题。这种方法确实可以，

但是我们也应当知道synchronize锁是要消耗资源了，所以直接用synchronize锁锁住getInstance方法的话，

每个线程来的时候都会额外造成synchronize锁带来的资源消耗问题。

所以聪明的程序员就又提出了DCL（双重检测锁）

我们不把synchronize锁加到getInstance方法上面，而是加到INSTANCE == null这个if判断的代码块上面，然后再在里面加上INSTANCE == null的判断

第一个if判断，是为了节省synchronize锁带来的额外资源消耗，保证一旦INSTANCE已经被实例化，后面的线程就不用再new 类的实例了。

而第二个if判断，则是为了解决线程安全问题，因为可能会有多个线程同时运行到INSTANCE == null这行代码，这就会造成多个线程会继续执行下去，执行 INSTANCE = new Mgr06();

这还是会产生多个不同的Mgr06的INSTANCE实例。但是多加一个INSTANCE == null判断，即使有多个线程同时运行到synchronize锁这个部分，但是这个代码块只能有一个线程进入，

所以第一个线程进入后，INSTANCE被实例化，其他线程之后进入后，也无法执行INSTANCE = new Mgr06()这行代码。

public class Mgr06 {
    private static Mgr06 INSTANCE;

    private Mgr06(){

    }
    public static Mgr06 getInstance(){
        if(INSTANCE == null){
            synchronized (Mgr06.class){
                if(INSTANCE == null){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
/*        Mgr03 m1 = Mgr03.getInstance();
        Mgr03 m2 = Mgr03.getInstance();
        System.out.println(m1 == m2);*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

静态内部类

我们已经说过饿汉式已经是一个比较完美的方法了，但是会造成资源浪费。

之后有聪明的程序员就想到了一个方法来避免这个缺点，就算在Mgr07类里面，创建一个静态内部类

一开始jvm在加载过程中，把INSTANCE加载到内存中，因为没有指定初始值，也会有类的静态代码块赋值。所以INSTANCE没有被初始化

这里我们需要了解一下静态内部类的一个特性：静态内部类是在外部类调用时才加载的，也就是说静态内部类可以在外部类加载之后，再加载到jvm中。

所以我们在静态内部类中设置一个静态变量，然后指定初始值。因为我们之前提到的类在加载过程中，静态变量只会被初始化一次，所以在jvm层面中，保证了

线程的安全性。因为静态内部类被调用之后才会加载初始化，所以就避免了资源浪费问题。

public class Mgr07 {
    private static Mgr07 INSTANCE;

    private Mgr07(){

    }
    private static class Mgr07Holder{
        private final static Mgr07 INSTANCE = new Mgr07();
    }
    public static Mgr07 getInstance(){
        return Mgr07Holder.INSTANCE;
    }

    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
/*        Mgr03 m1 = Mgr03.getInstance();
        Mgr03 m2 = Mgr03.getInstance();
        System.out.println(m1 == m2);*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }
}