单例模式的N种写法

1.前言

写完这个题目,我感觉自己好像"孔乙己"啊,回字的四种写法要不要学啊~

我们经常会用到单例模式,但是我对他一直没有一个统一的的认识,比如我清楚好多种单例的写法,但是每一种是怎么演化来的?具体解决了什么问题?这块就没有那么清晰了,因此此文对单例模式进行一个总结,同时手撸一下代码加深理解.

2.介绍

单例模式,即某一个类在整个系统中有且仅有一个实例.

经常用来读取配置,获取连接等等.

3.实现思路

1.构造方法私有化.
2.提供静态的方法,返回唯一实例.

这块很好理解,要想保证只有唯一实例,构造方法就不能被别人调用,只能自己调用用来创建唯一的实例,同时,将构造方法私有化了,就需要对外提供一个访问点,以方便其他类获取这个实例.

4.具体实现

4.1 饿汉式

这种写法的优势就是,真的简单,基本就是的实现思路的耿直实现,代码如下:

public class HungrySingleton { private static HungrySingleton hungrySingleton = new HungrySingleton(); private HungrySingleton() { } public static HungrySingleton getSingleton() { return hungrySingleton; } }

这样子有个问题,就是只要这个类被加载了,那么就会创建出唯一实例,也不管用不用...

虽然其实工作中问题不大,但是学习嘛,就要吹毛求疵,我们要懒加载的方式!

4.2 懒汉式

代码如下:

public class LazySingleton { private static LazySingleton lazySingleton = null; private LazySingleton() { } public static LazySingleton getSingleton() { if (null == lazySingleton) { lazySingleton = new LazySingleton(); } return lazySingleton; } }

这种方式也挺好理解的,而且实现了懒加载!只有在调用的时候才创建实例,节省了好大的空间呢!(并不)

但是这种方式仍然是有问题的,那就是著名的你有现在问题两个了.

如果多个线程同时来请求获取实例,上面这种懒汉式是解决不了的,会提供多个实例,也就违背了单例模式的初衷了(多个线程同时进入判空语句).

4.3 的懒汉优化一下

不就是线程安全吗?把我知道的volatile和synchronized都用上!

public class LazySingleton2 { private static volatile LazySingleton2 lazySingleton = null; private LazySingleton2() { } public static LazySingleton2 getSingleton() { synchronized (LazySingleton2.class) { if (null == lazySingleton) { lazySingleton = new LazySingleton2(); } } return lazySingleton; } }

这种方法看起来没有问题了,用volatilew修饰了唯一实例,保证内存可见性,用synchronized加锁,每次只允许一个线程访问判空语句,这不就解决了上面的问题吗?

是的,杀鸡用牛刀也不一定做的好啊..想想判空语句以及里面的实例化的执行频率,从理想的情况来讲,只有第一次会执行创建实例,剩下的都是返回实例就完事了.

为了这一种情况,每次都加锁,,性能下降太厉害了(其实并不,加了锁我们大部分时间也是够用的).

那再优化一下.

4.4 双重检查锁

代码如下:

public class DoubleCheckSingleton { private static volatile DoubleCheckSingleton singleton = null; private DoubleCheckSingleton() { } public static DoubleCheckSingleton getSingleton() { if (null == singleton) { synchronized (DoubleCheckSingleton.class) { if (null == singleton) { singleton = new DoubleCheckSingleton(); } } } //2 return singleton; } }

这就是传说中的双重检查锁了,说实话,这个代码看起来我觉得有点难看....

但是其实是比较好使的,大部分的获取实例请求都会直接来到//2位置,而极少量的为空进行加锁,保证线程安全.

双重检查锁对上一步的优化是:多添加一重判断,过滤掉大部分不需要加锁的操作,同时,加锁后再次进行判断,防止在第一次判断-加锁期间已经创建了实例.

4.5 静态内部类实现

public class InnerClassSingleton { private static class Holder { private static InnerClassSingleton singleton = new InnerClassSingleton(); } private InnerClassSingleton() { } public static InnerClassSingleton getSingleton() { return Holder.singleton; } }

我们可以把Singleton实例放到一个静态内部类中，这样就避免了静态实例在Singleton类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的：

4.6 枚举写法

上面的所有实现都有一点小问题:

1. 序列化与反序列化没有考虑,每次反序列化都能拿到一个新的实例.
2. 反射,都可以通过反射强行调用privite的构造方法.

这时候就是枚举类出现的时候了!

public enum EnumSingleton { SINGLETON; }

在《Effective Java》最后推荐了这样一个写法,看起来简直简单的有点不可思议,那么它是怎么保证以上几点的呢?

1. 枚举类的初始化过程天然线程安全.即保证了线程安全.
2. 对枚举的序列化与反序列禁止了自定义,由JDK实现,不会出现反序列化多个实例的情况.

在 《Effctive Java》中,作者极力推荐枚举实现单例,甚至说了它是单例实现的最好写法.

虽然我还没有应用过枚举实现单例,但是很快我就会将它加进我的代码库里.

总结

在单例实现中,我们需要注意以下三个问题:

1. (重要)延迟加载,避免浪费.
2. (重要)线程安全,避免多个实例.
3. 序列化安全.

完。

ChangeLog

2019-01-31 完成

以上皆为个人所思所得，如有错误欢迎评论区指正。

欢迎转载，烦请署名并保留原文链接。