单例模式的几种实现方式以及优缺点

转：http://blog.chenzuhuang.com/archive/13.html

 

 

背景

单例模式是一种常用的软件设计模式，常被用于一个类在系统中最多只允许存在一个实例的场合，如窗口管理器、打印缓冲池、文件系统等。在单例模式的核心结构中，只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。在Java中，单例模式如此定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”简而言之，单例模式就是保证一个类最多只能存在一个实例对象。

 

 

懒汉式

顾名思义，lazy loading（延迟加载，一说懒加载），在需要的时候才创建单例对象，而不是随着软件系统的运行或者当类被加载器加载的时候就创建。当单例类的创建或者单例对象的存在会消耗比较多的资源，常常采用lazy loading策略。这样做的一个明显好处是提高了软件系统的效率，节约内存资源。下面我们看看最简单的懒汉单例模式：

代码1-1

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Singleton {     private static Singleton singleton = null;    //私有的、类型为Singleton //自身的静态成员变量           //构造方法被设为私有，防止外部使用new来创建对象，破坏单例     private Singleton(){         System.out.println("构造函数被调用");     }           //公有的静态方法，供外部调用来获取单例对象     public static Singleton getInstance(){         if(singleton == null){    //第一次调用该方法时，创建对象。             singleton = new Singleton();         }         return singleton;     } }

 

在单线程环境下，多次调用getInstance()方法获得的Singleton对象均为同一个对象，单例模式实现成功。然而，在更多时候，软件系统工作于多线程环境下，因此不得不考虑线程安全的问题。

现有多线程测试程序如下：

代码1-2

?

1 2 3 4 5 6 7 8 9 10

public class TestThread {     public static void main(String[] args) {         Runnable run = () -> Singleton.getInstance();    //创建实现了Runnable // 接口的匿名类         for(int i = 0; i < 50; i++){             Thread thread = new Thread(run);             thread.start();         }     } }

 

代码中先创建了一个实现了Runnable接口的匿名类对象run，然后用for循环创建并启动50个线程，其中一次运行结果如下：

?

1 2 3 4

构造函数被调用 构造函数被调用 构造函数被调用 构造函数被调用

 

显然，Singleton的构造方法不止一次被调用，也就是说，Singleton存在四个实例对象，这违背了单例模式的初衷。这个实验说明，简单的懒汉式在多线程环境下不是线程安全的。有人提出在getInstance()方法上同步锁，但是锁住一整个方法可能粒度过大，不利于效率。既然锁方法不太好，那么锁代码呢？下面我们再看看两个例子：

代码1-3

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Singleton {     private static Singleton singleton = null;               private Singleton(){         System.out.println("构造函数被调用");     }           public static Singleton getInstance(){         if(singleton == null){             synchronized(Singleton.class){                 singleton = new Singleton();             }         }         return singleton;     } }

 

代码段1-3的getInstance()方法里，在判空语句后上锁，把singleton = new Singleton()语句锁住了，这样做看似解决了线程安全问题，其实不然。设现有线程A和B，在t1时刻线程A和B均已通过判空语句但都未取得锁资源；t2时刻时，A先取得锁资源进入临界区（被锁的代码块），执行new操作创建实例对象，然后退出临界区，释放锁资源。t3时刻，B取得被A释放的锁资源进入临界区，执行new操作创建实例对象，然后退出临界区，释放锁资源。明显地，Singleton被实例化两次。所以，如代码段1-3这样写也不能保证线程安全。

代码1-4

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Singleton {     private static Singleton singleton = null;               private Singleton(){         System.out.println("构造函数被调用");     }           public static Singleton getInstance(){             synchronized(Singleton.class){                 if(singleton == null){                 singleton = new Singleton();             }         }         return singleton;     } }

 

    代码段1-4把代码锁放在了判空语句前，这样做避免了代码段1-3的问题，然而这样做类似于在方法签名上加上synchronized关键字，会影响程序效率。因为当有多个线程几乎同时访问getInstance方法时，多个线程必须有次序地进入方法内，这样导致了若干个线程需要耗费等待进入临界区（被锁住的代码块）的时间。基于此，有人提出了双重校验锁式。

 

 

双重校验锁DCL(double checked locking)

双重校验锁式（也有人把双重校验锁式和懒汉式归为一类）分别在代码锁前后进行判空校验，避免了多个有机会进入临界区的线程都创建对象，同时也避免了代码段1-4后来线程在先来线程创建对象后但仍未退出临界区的情况下等待。双重校验锁代码如下：

代码2-1

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class Singleton{         private volatile static Singleton singleton = null;    //注意此处加上了 //volatile关键字         private Singleton(){         System.out.println("构造函数被调用");     }           public static Singleton getInstance(){         if(singleton == null){             synchronized(Singleton.class){                 if(singleton == null){                     singleton = new Singleton();                     //return singleton;    //有人提议在此处进行一次返回                 }                 //return singleton;    //也有人提议在此处进行一次返回             }         }         return singleton;     } }

 

经多次试验说明，双重校验锁式是线程安全的。然而，在JDK1.5以前，DCL是不稳定的，有时也可能创建多个实例，在1.5以后开始提供volatile关键字修饰变量来达到稳定效果。

 

对volatile关键字的特别说明：

有人认为使用volatile的原因是可见性，也就是可以保证线程在本地不会存有singleton副本，每次都是去主内存中读取，但是其实是不对的。使用volatile的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在volatile变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子：其中，singleton = new Singleton()并非是原子操作，事实上在JVM中这句话做了三件事：

1.给singleton变量分配内存

2.调用Singleton的构造函数来初始化成员变量

3.将singleton引用指向分配的空间

但是在JVM的即时编译器中存在指令重排序的优化，也就是说上面的第二步和第三步是不能保证顺序的，最终执行的顺序可能是1-2-3或者是1-3-2。如果是后者，则在3执行完毕，2执行之前，被线程2抢占了，这时instance已经是非null了（但却没有初始化），所以线程2会直接返回singleton，然后使用，然后会报错。

 假设没有关键字volatile的情况下，两个线程A、B，都是第一次调用该单例方法，线程A先执行singleton = new Singleton()，该构造方法是一个非原子操作，编译后生成多条字节码指令，由于JAVA的指令重排序，可能会先执行singleton的赋值操作，该操作实际只是在内存中开辟一片存储对象的区域后直接返回内存的引用，之后singleton便不为空了，但是实际的初始化操作却还没有执行，如果就在此时线程B进入，就会看到一个不为空的但是不完整（没有完成初始化）的Singleton对象，所以需要加入volatile关键字，禁止指令重排序优化，从而安全的实现单例。

 

• volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作：
• singleton=new Singleton()相当于对volatile变量singleton的写操作
• sychronized外面的if判断相当于对volatile变量singleton的读操作

 

 

饿汉式

单例模式的饿汉式，在定义自身类型的成员变量时就将其实例化，使得在Singleton单例类被系统（姑且这么说）加载时就已经被实例化出一个单例对象，从而一劳永逸地避免了线程安全的问题。代码如下：

代码3-1

?

1 2 3 4 5 6 7 8 9 10 11

public class Singleton{         private static Singleton singleton = new Singleton();    //在定义变量时 //就将其实例化         private Singleton(){         System.out.println("构造函数被调用");     }           public static Singleton getInstance(){         return singleton;     } }

 

使用多线程测试代码1-2进行测试，单例模式成功实现。

我想应该有朋友对饿汉式单例在何时被实例化感兴趣。可以编写如下简单测试代码：

代码3-2

?

1 2 3 4 5

public class TestThread {     public static void main(String[] args) {         Class.forName("Singleton");     } }

 

运行这段代码后可以看到控制台有“构造函数被调用”字符串输出，说明在ClassLoader加载Singleton类时，饿汉式单例就被创建。

虽然饿汉式单例是线程安全的，但也有其不足之处。饿汉式单例在类被加载时就创建单例对象并且长驻内存，不管你需不需要它；如果单例类占用的资源比较多，就会降低资源利用率以及程序的运行效率。有一种更高级的单例模式则很好地解决了这个问题——静态内部类。

 

 

IoDH(Initialization Demand Holder)——通过静态内部类实现线程安全的单例模式

静态内部类式在Singleton类内部定义了一个静态的内部类，在该内部类里创建Singleton的单例对象。我们先看代码：

代码4-1

?

1 2 3 4 5 6 7 8 9 10 11 12 13

public class Singleton {     private Singleton(){         System.out.println("构造函数被调用");     }           public static Singleton getInstance(){         return SingletonHolder.instance;     }           private static class SingletonHolder{         private static Singleton instance = new Singleton();     } }

 

静态内部类式和饿汉式一样，同样利用了ClassLoader的机制保证了线程安全；不同的是，饿汉式在Singleton类被加载时（从代码段3-2的Class.forName可见）就创建了一个实例对象，而静态内部类即使Singleton类被加载也不会创建单例对象，除非调用里面的getInstance()方法。因为当Singleton类被加载时，其静态内部类SingletonHolder没有被主动使用。只有当调用getInstance方法时，才会装载SingletonHolder类，从而实例化单例对象。

这样，通过静态内部类的方法就实现了lazy loading，很好地将懒汉式和饿汉式结合起来，既实现延迟加载，保证系统性能，也能保证线程安全。

 

然而，对于上述四种方式的单例模式，如果你的Singleton类实现了Serializable序列化接口，那么可能会被序列化生成多个实例，因为readObject()方法一直返回一个新的对象：

?

1 2 3 4 5 6

ByteArrayOutputStream baos  = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(singleton);    ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray())); Singleton singleton=  (Singleton) ois.readObject();

 

这种情况可以通过在Singleton类添加readResolve()方法来解决：

?

1 2 3 4

private Object readResolve() {         System.out.println("readResolve()被调用");         return getInstance(); }

 

但是这种解决方案虽解决了序列化的问题，但是无法避免被反射。下面还有一种枚举单例，写法简单，还可以避免序列化、反射的问题。

 

 

枚举单例

上面说到的静态内部类方式不失为一个高级的单例模式实现。但如果开发要求更严格一些，比如你的Singleton类实现了序列化，又或者想避免通过反射来破解单例模式的话，单例模式还可以有另一种形式。那就是枚举单例。枚举类型在JDK1.5被引进。这种方式也是《Effective Java》作者Josh Bloch 提倡的方式，它不仅能避免多线程的问题，而且还能防止反序列化重新创建新的对象、防止被反射攻击。代码如下：

代码5-1

?

1 2 3 4 5 6 7 8 9 10 11

public enum EnumSingleton {     INSTANCE{         @Override         protected void work() {             System.out.println("你好，是我!");         }               };           protected abstract void work();    //单例需要进行操作（也可以不写成抽象方法） }

 

在外部，可以通过EnumSingleton.INSTANCE.work()来调用work方法。默认的枚举实例的创建是线程安全的，但是实例内的各种方法则需要程序员来保证线程安全。总的来说，使用枚举单例模式，有三个好处：1.实例的创建线程安全，确保单例。2.防止被反射创建多个实例。3.没有序列化的问题。