Java多线程编程-（10）-单例模式几种写法的错与对

背景知识

在所有的主流23中设计模式中，单例模式作为最简单也最容易理解也是使用最普遍的设计模式，他是一种对象创建模式，用于产生一个对象的具体实例，他可以确保系统中一个类只产生一个实例。

单例模式的优点如下：

1、对于频繁创建的对象，可以省去new的操作锁花费的时间，对于一些重量级的对象创建来说可以说是一笔开销的节省；

2、由于new的次数变少了，系统内存的使用频率也会降低，这也减轻了GC的压力，缩短了GC停顿的时间，这是因为GC收集的时候去阻塞程序的执行。

为什么会在多线程这里说道单利模式那？这是因为在多线程情况下不正确的使用单利模式会造成整个程序的错误执行，因此单利模式我们也应该坐下来细细研究一下！

网上流传着“单利模式的七种写法”这里我也做了一下整理，放在了码云，有需要的可以自取，地址为：https://gitee.com/xuliugen/codes/91478ndt3kxhp2muivr5o61

这里写图片描述

单利模式的七种写法主要是：懒汉模式线程不安全、懒汉模式线程安全、饿汉模式、变种的饿汉模式、双重校验锁DCL、静态内部类、枚举类型。

下边主要分析一下：饿汉模式、懒汉模式线程安全、双重校验锁DCL、静态内部类四种，其他几种大致类似，不在赘述。

饿汉模式

饿汉模式代码如下：

public class Singleton {

    private static Singleton instance = new Singleton(); //第一行

    private Singleton (){ //第二行

    }

    public static Singleton getInstance() { //第三行
        return instance;
    }
}

作为单利模式，有以下几点要求：

1、实例对象必须是private，并且是static的，是private是可以保证安全性，是static是因为第三行代码是static的方法，所以该变量也必须是static的；

2、构造方法必须是私有的，这样的话就可以避免其他任意调用的情况，也就是上述代码的第二行；

3、第三行代码，是公有的、静态的这样的话可以直接通过Singleton .getInstance() 进行调用；

这种方式很简单，性能在多线程情况下也很好，但是有一个问题，继续看下边的代码：

public class Sintelon {

    private static Sintelon instance = new Sintelon();

    public static String VARIABLE = "hello world!"; //第一段

    private Sintelon() {
        System.out.println("Singtelon is created!");
    }

    public static Sintelon getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println(Sintelon.VARIABLE); //第二段
        }
    }
}

执行结果：

这里写图片描述

但是我们要注意：在第一段代码中我们声明了一个static变量，在第二段代码中调用了该变量，但是执行的结果确调用了构造方法，我们知道单利模式只有在第一次调用获取实例instance的时候，才可以调用私有的构造方法的，那么这里我们没有任何的代码调用getInstance()方法，很显然无法精确地控制instance创建的精确时间，如果代码如上所示的话，也是一种错误的方法。

看似简答的设计模式，如果不正确的使用，很难很精确的控制到我们想要的结果，有人要说了，既然这样我们以后不再“饿汉模式”代码里使用static变量不就OK了！是的，是可以，但是如果我们使用“懒汉模式线程安全”的方式就可以很好的控制instance的创建时间，不会出现上述的调用static变量就创建了实例。

懒汉模式线程安全

懒汉模式线程安全代码如下：

public class LazySintelon {

    private static LazySintelon instance;

    public static String VARIABLE = "hello world!";

    private LazySintelon() {
        System.out.println("LazySintelon is created!");
    }

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

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(LazySintelon.VARIABLE);
        }
    }
}

运行结果如下：

这里写图片描述

可以看出，只要我们不调用getInstance() 方法，就不会出现instance，就可以很好的保证了第一次调用的时候创建对象。

双重校验锁DCL

这里为什么提出双重校验锁DCL这种方式，是因为很多人都认为双重校验锁DCL是一种非常丑陋、复杂的方法，不信看一下代码：

public class Singleton {

    private volatile static Singleton singleton;

    private Singleton (){
    }

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

怎么说哪？代码量确实比较多，并且难以理解，为什么使用volatile ，以及为什么是两次判空，这些都很难理解，并且在一些低版本的JDK还不能够保证执行的正确性，所以代码中也不推荐大家用，但作为一种思想还是有必要研究一下！

有兴趣的可参考：http://blog.csdn.net/xlgen157387/article/details/78005352

静态内部类

静态内部类可以说是集成了上述代码的所有优点，也是特意推荐的一种，代码如下：

public class Singleton {

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

    private Singleton (){

    }

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

简单分析一下：

1、可以实现延迟加载的功能，只有在调用getInstance（）的方法才会创建单例对象，并且是通过类加载器机制保证值创建一个单例对象；

2、JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。

3、对于Java类加载机制来说，当第一次访问类的静态字段的时候，会触发类加载，并且同一个类只加载一次。静态内部类也是如此，只会被加载一次，类加载过程由类加载器负责加锁，从而保证线程安全。

代码简单明了，值得信赖！