单例模式 - Singleton Patterns
Posted 有且仅有
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了单例模式 - Singleton Patterns相关的知识,希望对你有一定的参考价值。
父博文地址:设计模式 - Design Patterns
一、单例模式的意义
Design Patterns 一书中对单例模式描述:
Ensure a class only has one instance, and provide a global point of access to it.
确保一个Class只有一个实例,并对外提供一个全局访问点。
单例模式是最容易理解的设计模式。道理简单,不过如何写出一个“正确”的单例模式一开始并不简单。Talk is cheap. Show me the code.
单例模式的代码有两种不同的方式,一种被叫做所谓的“饿汉式”,另一种叫“懒汉式”。
二、饿汉方式
饿汉的意思是:急切的……,即急切的创建实例。代码如下:
/**
* “饿汉式”,即“急切的方式”。
*/
public class Singleton
private static Singleton instance = new Singleton();
private Singleton()
public static Singleton getInstance()
return instance;
优点:实现简单、线程安全,JVM保证在任何线程能访问
instance
之前,实例化new Singleton()
已被执行完成。缺点:如果实例化
new Singleton()
很耗资源,而对象在很久之后才会被用到或者本次程序运行中都用不到,则浪费了系统资源。
三、懒汉方式(懒加载)
针对“急切方式”的缺点,可以使用这种称为“懒加载”的方式来实现单例模式。
1. 第一遍代码:错误代码1
/**
* 懒汉式,错误代码1
* <p>
* 错误原因:线程不安全。安全写法见$@link LazyInitializationCorrect
* </p>
*/
public class LazyInitializationError
private static LazyInitializationError instance;
private LazyInitializationError()
public static LazyInitializationError getInstance()
if (instance == null)
instance = new LazyInitializationError();
return instance;
错误发生流程:
- 线程
Thread1
执行完if (instance == null)
后失去了CPU执行权。 - 线程
Thread2
再次执行了if (instance == null)
并得到true
,然后它也失去执行权。 Thread1
恢复执行,实例化了一个对象并赋值给了instance
,return
给调用方。Thread2
恢复执行,它不知道instance
已经不为null
,所以会再次实例化一个新对象并return
给调用方。
2. 第二遍代码:有性能损耗
/**
* 懒汉式,性能有损耗
*/
public class LazyInitializationSlowly
private static LazyInitializationSlowly instance;
private LazyInitializationSlowly ()
public static synchronized LazyInitializationSlowly getInstance()
if (instance == null)
instance = new LazyInitializationSlowly();
return instance;
缺点:每次调用getInstance()
都需要先获取锁,造成资源损耗。
3. 第三遍代码:错误代码2
使用Double-checked locking 可以避免效率降低,请看以下代码。不过注意:下面代码其实仍有问题,具体在注释中。
/**
* 懒汉式,错误代码2
*
* <p>
* 使用了“Double-checked locking”,但不幸的是,在Java环境下注意这是又一个错误的写法,错误描述见代码注释
* <br>安全写法见$@link LazyInitializationCorrect
* </p>
*/
public class LazyInitializationErrorNoVolatile
private static LazyInitializationErrorNoVolatile instance;
private LazyInitializationErrorNoVolatile()
/**
* Double-checked locking
*/
public static LazyInitializationErrorNoVolatile getInstance()
// first check 第一次检查并不会尝试获取锁,避免了性能损耗
if (instance == null)
synchronized (LazyInitializationErrorNoVolatile.class)
// double check
if (instance == null)
instance = new LazyInitializationErrorNoVolatile();
// 一、上面这句代码在JVM中被分解为3个指令
// 1. 为对象分配内存空间(例如内存地址为:10001)。
// 2. 调用构造函数初始化对象。
// 3. 局部变量instance 指向对象被分配的内存空间。(即10001,执行完这步后instance 非null )
// 二、问题:
// 由于JVM的JIT编译器存在着称为“指令重排序”的优化行为,所以上面这行代码的指令执行顺序并非一定是“1-2-3”,
// 有可能被优化为“1-3-2”,这在Java内存模型中是完全合法的。所以错误出现在:
// 1. Thread1执行指令的顺序为“1-3-2”且在执行了“1-3”后丢失了CPU的执行权,此时3已执行所以instance为非null;
// 2. Thread2获取执行权,当执行到first check 时,发现结果为false所以直接return instance,然而此时instance指向的对象并没有初始化完成,随即程序可能崩溃。
// 三、解决问题:
// JDK1.5后volatile的语义被扩展了,使用volatile关键字即可解决。
// volatile的一个语义是:阻止指令重排序优化,使得上面执行的顺序必须是“1-2-3”即可。
return instance;
4. 第四遍代码:正确写法
即上例代码的有volatile
版本。
/**
* 懒汉式,正确写法
*/
public class LazyInitializationCorrect
private static volatile LazyInitializationCorrect instance;
private LazyInitializationCorrect()
public static LazyInitializationCorrect getInstance()
// Double-checked locking
if (instance == null)
synchronized (LazyInitializationCorrect.class)
if (instance == null)
instance = new LazyInitializationCorrect();
return instance;
四、另一种正确的懒加载
懒加载还有一种效率更高的正确写法叫 Initialization-on-demand holder idiom,这种方式效率很高因为没有同步代码,当然它也有一定的局限性,这些在注释中详细的写了出来:
/**
* 懒汉式,使用Hodler方式
*
* <p>完全线程安全,“Initialization-on-demand holder idiom”,但有一定限制</p>
*/
public class LazyInitializationCorrectWithHolder
private LazyInitializationCorrectWithHolder()
// 1. LazyInitializationCorrectWithHolder被JVM加载时,如果Holder类没被任何代码引用到的话,是不会被加载的,所以这里满足了“懒”;
private static class Holder
private static final LazyInitializationCorrectWithHolder INSTANCE = new LazyInitializationCorrectWithHolder();
public static LazyInitializationCorrectWithHolder getInstance()
// 2. 当外部代码调用 getInstance() 时,Holder才会被加载并执行;
// 3. 又由于JVM保证了class的初始化是按照既定顺序的,不会多线程的,所以 INSTANCE 的初始化是线程安全的。
return Holder.INSTANCE;
// 4. 使用这种风格的单例,必须满足一个条件,构造函数的过程不能发生异常导致初始化失败。(double checked方式没有这个限制)
// 错误代码如下,当初始化失败后,其它线程也不能再次完成初始化了,因为会一直发生LazyInitializationCorrectWithHolder$Holder NoClassDefFoundError
// private LazyInitializationCorrectWithHolder()
// if (Thread.currentThread().getName().equals("Threadddd-0"))
// int i = 1/0;
//
//
// public static void main(String[] args)
// for (int i = 0; i < 3; i++)
// final Thread thread = new Thread(new Runnable()
// @Override
// public void run()
// getInstance();
//
// );
// thread.setName("Threadddd-" + i);
// thread.start();
//
//
单例模式很简单,不过如果你一开始无法预料到一些潜在的问题,其实也很难写出正确的代码。看过了这篇文章,相信你再也写不错了。
转载注明出处:http://blog.csdn.net/u010297957/article/details/70544003
以上是关于单例模式 - Singleton Patterns的主要内容,如果未能解决你的问题,请参考以下文章