Java 设计模式之单例模式

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

单例模式的类没有公开的构造方法，当需要实例时，从类提供的全局访问点去获取，它会返回单个实例。

对于单例，有多种实现方法。比如饿汉式，顾名思义，先一口吃饱，将对象实例化出来再说

public class HungryStyleSingleton {

    /**
     * 饿汉式
     * 一开始就实例化对象，当访问类的全局访问点的时候就返回这个对象，是线程安全的
     */
    private static final HungryStyleSingleton SINGLETON = new HungryStyleSingleton();

    private HungryStyleSingleton() {

    }

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

懒汉式。等需要的时候再实例化对象给你，不急不急。

public class LazyStyleSingleton {

    private static LazyStyleSingleton instance;

    private LazyStyleSingleton() {

    }

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

}

看起来似乎是懒汉式更好一些，在没有使用的时候不浪费资源。但是，当有多个线程同时需要获取单例的时候又产生不同对象的可能，也就是线程不安全的问题。来简单验证下

实现一个Runnable接口

public class SingletonRunnable implements Runnable{

    @Override
    public void run() {
        LazyStyleSingleton singleton = LazyStyleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" +singleton);
    }
}

然后启动两个线程

Thread t1 = new Thread(new SingletonRunnable());
Thread t2 = new Thread(new SingletonRunnable());

t1.start();
t2.start();

观察控制台输出的内容，多运行几次会发现，两个线程有获取相同的对象，也有获取的是不同的对象

// 第一次输出的对象地址
LazyStyleSingleton@275635de
LazyStyleSingleton@37e684d

// 第二次输出的对象地址
LazyStyleSingleton@4ed00e29
LazyStyleSingleton@4ed00e29

很明显，问题出现在懒汉模式下对象的实例化上，断点调试来看下

将两个线程的全都运行到断点这里

接下来就会有很多种情况，如果两个线程不分先后的都在对象还没有实例化之前也就是instance==null 为 true 的时候到达了下一步实例化，然后快的一个现成执行玩了整个流程，慢的那一个线程才开始实例化，这样就会产生两个不一样的对象。如果在进if之前一前一后相差较大那么就是同一个实例化对象。当然，这种差距放在线程实际执行的时候是无法感知到的，断点可以帮助我们更好的理解这一现象。

既然问题出在了这里，那么让对象在实例化的时候无法异步，必须同步创建就可以了。可以采用双重加锁的方式

public class LazyStyleSingleton {

    private volatile static LazyStyleSingleton instance;

    private LazyStyleSingleton() {

    }

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

}

这样一来，就只有在第一次创建对象的时候才执行同步操作，并且进入同步操作之后再检查一次，如果还为空才创建对象，最大的减少了同步所带来的的时间耗费。使用volatile关键词确保instance在初始化时在多个线程之间的可见性，多个线程能正确的处理instance变量。

通过静态内部类来实现的单例

public class StaticNestedClassSingleton {

    private StaticNestedClassSingleton() {

    }

    public static StaticNestedClassSingleton getInstance() {
        return SingletonHolder.SINGLETON;
    }

    private static class SingletonHolder{
        private static final StaticNestedClassSingleton SINGLETON = new StaticNestedClassSingleton();
    }
}

这种实现方式减少了同步加锁的操作，更加的简洁明了。在通过全局访问点获实例时，通过静态内部类的静态变量来得到实例化的对象，在此之前，内部类的初始化 已经完成，调用getInstance方法时，就可以直接得到实例化的对象，多个线程的话也不会有线程安全的问题。