【设计模式系列（二）】彻底搞懂单例模式

文章中涉及到的代码，可到这里来拿：https://gitee.com/daijiyong/DesignPattern

概念：单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点

关键点是：单例类中有一个静态的变量，私有化构造方法，提供唯一全局调用方法，并选择一个时机进行初始化

属于创建型模式

它主要是为了解决：一个全局使用的类频繁地创建与销毁所造成的资源开销

单例模式比较简单，最复杂的地方在于如何保证多线程、序列化等情况下

仍然保证单例实例的唯一性

使用场景：

配置文件，如ServletContext、ServletConfig、ApplicationContext、数据库连接池
要求生产唯一序列号
WEB 中的计数器，不用每次刷新都在数据库中同步一次，可以用单例先缓存起来

1. 饿汉式

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
}

在类加载的时候实例就初始化了

所以基于 classloader 机制很好的避免了多线程情况下的同步问题

还有一种写法是这样的

public class HungrySingleton {
    private static HungrySingleton instance;
    static {
        instance = new HungrySingleton();
    }
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
}

类加载顺序：

先静态后动态、先上后下、先属性后方法

所以这种写法也能满足在类加载的时候就能初始化的要求

懒汉式的优点是：执行效率高，性能高（没有加锁）

缺点：不过不是明确需要初始化这个实例，存在内存浪费的情况

2. 懒汉式单例

为了解决饿汉式中存在的内存浪费的情况

我们可以采用懒汉式

public class LazySimpleSingleton {
    private static LazySimpleSingleton instance;
    private LazySimpleSingleton() {
    }
    public static LazySimpleSingleton getInstance() {
        if (instance == null) {
            instance = new LazySimpleSingleton();
        }
        return instance;
    }
}

懒汉式在类加载的时候不会初始化单例

只有被被外部调用的时候才会创建

下面我们测试一下多线程情况下，这种单例的实现方式能否安全

写一个实现了Runable接口的类

在run方法中调用单例模式的实例

/**
 * @author daijiyong
 */
public class TestLazySingletonThread implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName() + LazySimpleSingleton.getInstance());
    }
}

编写主函数，写三个线程进行测试

/**
 * @author daijiyong
 */
public class Test {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new TestLazySingletonThread());
        Thread thread2 = new Thread(new TestLazySingletonThread());
        Thread thread3 = new Thread(new TestLazySingletonThread());
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

显而易见，多线程下并没有保证线程安全

创建了多个单例的对象

其中线程1用的是一个实例

线程0和线程2用的另外一个实例

为什么会出现这个情况呢？

首先我们得知道，Java中线程类的start()方法，并不是会立马执行当前线程

仅仅是告知cpu，你需要执行当前线程，具体什么时候执行，看心情

所以虽然我们是按照thread1、thread2、thread3的顺序执行的start()方法，但是执行顺序却并一定是这样的

而且他们三个的执行顺序可能在不同的时间点，也是不一样的，完全随缘

所以，即便打印出来的两个线程的实例是一样的，也不代表这个单例只被创建了一次

也有可能是创建了两个实例，但是在返回结果之前，第二个实例已经创建完了，将第一个实例覆盖了

怎么优化？第一个想到的应该就是加锁

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

这样随便执行，就不会出现线程不安全的问题了

但是当我这打了一个断点，查看三个进程执行情况的时候发现了下面的问题

线程0是执行runing状态，但是其他两个线程是监听monitor状态

当执行的线程特别多的时候，会就导致有大量的线程处于等待监听状态

synchronized关键字，是解决了线程安全问题

但是导致在同一个时间只能有一个调用，性能会极速下降

为了解决这个，我们还有一个办法

双重检验方法

public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton() {
    }
    public static LazyDoubleCheckSingleton getInstance() {
        //是否要线程阻塞
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //是否要创建实例
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

第一个检验是为了判断，是否已经初始化了单例

如果已经创建了，则不进行线程阻塞，直接返回

第二个检验是为了判断，在没有初始化的情况下，需要初始化，此时是否因为线程阻塞的原因，已经初始化了

如果已经初始化，则直接返回，如果没有，则进行线程初始化

除了双重检验，还有一个更好的方法来实现懒汉模式

静态内部类

public class LazyStaticInnerClassSingleton {
    private LazyStaticInnerClassSingleton() {
        //防止通过Java反射机制创建实例
        if (LazyHolder.INSTANCE != null) {
            throw new RuntimeException("不允许非法访问");
        }
    }
    private static LazyStaticInnerClassSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }
}

这个看起来是饿汉式的写法

但是其实是懒汉式的

这个主要是利用了java类加载的时候，默认是不会加载内部类的机制

只有在调用使用内部类的时候才会对内部类实现初始化

classloader 机制保证了初始化 instance 时只有一个线程

这样就很好的解决了线程不安全的问题

优雅、高级、装*

3. 枚举式单例

public enum EnumSingleton {
    /**
     * 实例
     */
    INSTANCE;
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法

它更简洁，利用枚举类自身特点

不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化

为什么呢？

我们可以看一下源码

从Java的源码可以看到

Java在底层就禁止了通过反射的方法创建枚举对象

所以在原生层面就解决了反射机制破坏单例模式的问题

那枚举类是如何保证线程安全的呢？

这个问题问的好，我们在看看源码

由此可知，枚举类在加载的时候

会将每一个枚举类的实例元素放到一个Map当中

这个操作在程序启动、类加载的时候就完成了

之后每次取对象，都是从map中拿的

所以绝对线程安全

但是枚举方式跟饿汉方式一样

是存在内存浪费的情况的

为了解决这个问题，还有一种写法

4. 容器式单例

public class ContainerSingleton {
    private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>(16);
    private ContainerSingleton() {
    }
    public static Object getInstance(String className) {
        if (!ioc.containsKey(className)) {
            try {
                synchronized (ioc) {
                    Object instance = Class.forName(className).newInstance();
                    ioc.put(className, instance);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return ioc.get(className);
    }
}

将每一个实例都缓存到统一的容器当中，使用唯一标识获取实例

当容器中不存在时，则对容器加锁并创建，之后返回

如果已经存在，则直接返回

使用这种方法可以完美的解决多线程和反射带来的问题

5. ThreadLocal单例

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
            new ThreadLocal<ThreadLocalSingleton>() {
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton() {
    }
    public static ThreadLocalSingleton getInstance() {
        return threadLocalInstance.get();
    }
}

ThreadLocal单例能够保证在一个线程内部的全局唯一，天生线程安全

跨线程的时候，保证不是同一个单例实例

这种实现方式的应用场景非常清晰了

用在多线程中，保证在一个线程中的单例实现

6. 总结

单例模式

优点：

减少内存开销

避免对资源的多重占用

设置全局访问点，严格控制访问

缺点：

没有接口，扩展困难，如果要扩展，只能修改代码，违背了开闭原则