剑指offer面试题2：实现Singleton模式（Java版）

1、问题描述

设计一个类，我们只能生成该类的一个实例。

2、解题思路

只能生成一个实例的类是实现了Singleton(单例)模式的类型。

3、实现方案

解法一：懒汉式单例

懒汉式单例模式在第一次调用的时候进行实例化。

3.1 只适用于单线程环境的单例模式

由于要求只能生成一个实例，因此我们必须把构造函数设为私有函数以禁止他人创建实例。可以定义一个静态的实例，在需要的时候创建该实例。

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

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

    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        Singleton s2 = s;
        Singleton s3 = Singleton.getInstance();
        System.out.println(s == s2);
        System.out.println(s == s3);
    }
}

上述代码在Singleton类的静态属性instance中，只有在instance为null的时候才创建一个实例以避免重复创建。同时我们把构造函数定义为私有函数，这样就能确保只创建一个实例。

可以运行main函数看到结果为，两个true。说明两次调用Singleton类的getInstance()方法，却只创建了一个实例。

3.2 可以在多线程环境中工作，但效率不高的单例模式

解法一中的代码在单线程的时候工作正常，但在多线程的情况下就有问题了。设想如果两个线程同时运行到判断instance是否为null的if语句，并且instance的确没有创建时，那么两个线程都会创建一个实例，此时类型Singleton就不再满足单例模式的要求了。

为了保证在多线程环境下我们还是只能得到该类的一个实例，只需要在getInstance()方法加上同步关键字sychronized，就可以了。

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

这样需要可以实现在多线程环境保证只创建一个实例，但每次调用getInstance()方法时都被synchronized关键字锁住了，会引起线程阻塞，会影响程序的性能。

3.3 双重锁定的单例模式

为了在多线程环境下，不影响程序的性能，不让线程每次调用getInstance()方法时都加锁，而只是在实例未被创建时再加锁，在加锁处理里面还需要判断一次实例是否已存在，这种做法被称为“双重锁定”。

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

3.4 使用静态内部类实现的单例模式

public class Singleton {
    //构造函数设置为私有的，以禁止在其他类中创建实例
    private Singleton() {
    }
    //静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

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

这种比3.1和3.2都好一些，既实现了线程安全，又避免了同步带来的性能影响，任何时候都不会发生阻塞。

解法二：饿汉式单例

饿汉式单例类:在类初始化时，已经自行实例化。

public class Singleton {

    private Singleton() {
    }

    private static final Singleton SINGLETON = new Singleton();

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

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

饿汉式单例与懒汉式单例的比较

• 饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了；
• 懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

从线程安全和资源加载和性能两个方面区分这两种方式：

1、线程安全：

• 饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题；
• 懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的3.2，3.3，3.4，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

• 饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成；
• 懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。