(转) 设计模式——小单例有大秘密

原创 2013年12月05日 16:07:00

 

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。

下面是一个简单的小实例:

  1. //简单懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法,保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.           
  13.         if (instance == null) {   
  14.             instance = new Singleton();   
  15.         }  
  16.           
  17.         System.out.println("我是简单懒汉式单例!");  
  18.         return instance;  
  19.     }  
  20. }  


很容易看出,上面这段代码在多线程的情况下是不安全的,当两个线程进入if (instance == null)时,两个线程都判断instance为空,接下来就会得到两个实例了。这不是我们想要的单例。

 

接下来我们用加锁的方式来实现互斥,从而保证单例的实现。

  1. //同步法懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法,保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static synchronized  Singleton getInstance() {  
  12.           
  13.         if (instance == null) {   
  14.             instance = new Singleton();   
  15.         }  
  16.           
  17.         System.out.println("我是同步法懒汉式单例!");  
  18.         return instance;  
  19.     }  
  20. }  

加上synchronized 后确实保证了线程安全,但是这样就是最好的方法吗?很显然它不是,因为这样一来每次调用getInstance()方法是都会被加锁,而我们只需要在第一 次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。

 

经过分析发现,只需要保证instance = new Singleton()是线程互斥就可以保证线程安全,所以就有了下面这个版本:

  1. //双重锁定懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法,保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.         if (instance == null) {   
  13.             synchronized (Singleton.class) {  
  14.                 if (instance == null) {   
  15.                     instance = new Singleton();   
  16.                 }  
  17.             }  
  18.         }  
  19.         System.out.println("我是双重锁定懒汉式单例!");  
  20.         return instance;  
  21.     }  
  22. }  

这次看起来既解决了线程安全问题,又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案,事实上是这样的吗?

很遗憾,事实并非我们想 的那么完美。java平台内存模型中有一个叫“无序写”(out-of-order writes)的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行:instance = new Singleton(); 这行其实做了两个事情:1、调用构造方法,创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是,这两步jvm是不保证顺序 的。也就是说。可能在调用构造方法之前,instance已经被设置为非空了。下面我们一起来分析一下:

 

假设有两个线程A、B

1、线程A进入getInstance()方法。

2、因为此时instance为空,所以线程A进入synchronized块。

3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。(注意,是在调用构造方法之前。)

4、线程A退出,线程B进入。

5、线程B检查instance是否为空,此时不为空(第三步的时候被线程A设置成了非空)。线程B返回instance的引用。(问题出现了,这时instance的引用并不是Singleton的实例,因为没有调用构造方法。) 

6、线程B退出,线程A进入。

7、线程A继续调用构造方法,完成instance的初始化,再返回。 

 

难道就没有一个好方法了吗?好的方法肯定是有的,我们继续探索!

  1. //解决无序写问题懒汉式  
  2. public class Singleton {  
  3.       
  4.     //单例实例变量  
  5.     private static Singleton instance = null;  
  6.       
  7.     //私有化的构造方法,保证外部的类不能通过构造器来实例化  
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例  
  11.     public static Singleton getInstance() {  
  12.         if (instance == null) {   
  13.             synchronized (Singleton.class) {                  //1  
  14.                 Singleton temp = instance;                //2  
  15.                 if (temp == null) {  
  16.                     synchronized (Singleton.class) {  //3   
  17.                         temp = new Singleton();   //4      
  18.                     }  
  19.                     instance = temp;                  //5        
  20.                 }  
  21.             }  
  22.         }  
  23.         System.out.println("我是解决无序写懒汉式单例!");  
  24.         return instance;  
  25.     }     
  26. }  


1、线程A进入getInstance()方法。

2、因为instance是空的 ,所以线程A进入位置//1的第一个synchronized块。

3、线程A执行位置//2的代码,把instance赋值给本地变量temp。instance为空,所以temp也为空。 

4、因为temp为空,所以线程A进入位置//3的第二个synchronized块。(后来想想这个锁有点多余)

5、线程A执行位置//4的代码,把temp设置成非空,但还没有调用构造方法!(“无序写”问题) 

6、如果线程A阻塞,线程B进入getInstance()方法。

7、因为instance为空,所以线程B试图进入第一个synchronized块。但由于线程A已经在里面了。所以无法进入。线程B阻塞。

8、线程A激活,继续执行位置//4的代码。调用构造方法。生成实例。

9、将temp的实例引用赋值给instance。退出两个synchronized块。返回实例。

10、线程B激活,进入第一个synchronized块。

11、线程B执行位置//2的代码,把instance实例赋值给temp本地变量。

12、线程B判断本地变量temp不为空,所以跳过if块。返回instance实例。

 

到此为止,上面的问题我们是解决了,但是我们突然发现为了解决线程安全问题,但给人的感觉就像身上缠了很多毛线.... 乱糟糟的,所以我们要精简一下:

  1. //饿汉式  
  2. public class Singleton {  
  3.       
  4.     //单例变量 ,static的,在类加载时进行初始化一次,保证线程安全   
  5.     private static Singleton instance = new Singleton();      
  6.       
  7.     //私有化的构造方法,保证外部的类不能通过构造器来实例化。       
  8.     private Singleton() {}  
  9.       
  10.     //获取单例对象实例       
  11.     public static Singleton getInstance() {  
  12.         System.out.println("我是饿汉式单例!");  
  13.         return instance;  
  14.     }  
  15. }  

看到上面的代码,瞬间觉得这个世界清静了。不过这种方式采用的是饿汉式的方法,就是预先声明Singleton对象,这样带来的一个缺点就是:如果构造的单例很大,构造完又迟迟不使用,会导致资源浪费。

 

到底有没有完美的方法呢?继续看:

  1. //内部类实现懒汉式  
  2. public class Singleton {  
  3.       
  4.     private static class SingletonHolder{  
  5.         //单例变量    
  6.         private static Singleton instance = new Singleton();  
  7.     }  
  8.       
  9.     //私有化的构造方法,保证外部的类不能通过构造器来实例化。  
  10.     private Singleton() {  
  11.           
  12.     }  
  13.       
  14.     //获取单例对象实例  
  15.     public static Singleton getInstance() {  
  16.         System.out.println("我是内部类单例!");  
  17.         return SingletonHolder.instance;  
  18.     }  
  19. }  

懒汉式(避免上面的资源 浪费)、线程安全、代码简单。因为java机制规定,内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被 加载(实现了lazy),而且其加载过程是线程安全的(实现线程安全)。内部类加载的时候实例化一次instance。

 

简单说一下上面提到的无序写,这是jvm的特性,比如声明两个变量,String a; String b; jvm可能先加载a也可能先加载b。同理,instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问,说还没有实例化出 Singleton的一个对象,那么instance怎么就变成非空了呢?它的值现在是什么呢?想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的,下面用一段伪代码向大家解释一下:

  1. mem = allocate();             //为Singleton对象分配内存。  
  2. instance = mem;               //注意现在instance是非空的,但是还没有被初始化。  
  3.   
  4. ctorSingleton(instance);    //调用Singleton的构造函数,传递instance.  

 

由此可见当一个线程执行 到instance = mem; 时instance已为非空,如果此时另一个线程进入程序判断instance为非空,那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance,现在的值为allocate();返回的内存对象。所以第二个线程得到 的不是Singleton的一个对象,而是一个内存对象。

 

以上就是就是我对单例模式的一点小小的思考跟理解,热烈欢迎各位大神前来指导批评。

菜鸟学设计模式(一)——小单例有大秘密

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。 下面是一个简单的小实例: //简单懒汉...
  • liushuijinger
  • liushuijinger
  • 2013年06月17日 08:58
  • 20288

设计模式——小单例有大秘密

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。 下面是一个简单的小实例: packa...
  • u010709330
  • u010709330
  • 2013年06月19日 13:39
  • 419

小单例有大秘密

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同。 下面是一个简单的小实例: ...
  • lm16875
  • lm16875
  • 2013年06月23日 23:11
  • 377

单例设计模式——小单例有大秘密

单例模式大家并不陌生,也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗,单例模式是否线程安全呢?今天我带大家一起来看看我眼中的单例,可能会跟你的认识有所不同...
  • Jason_huzhe
  • Jason_huzhe
  • 2016年04月28日 12:18
  • 208

微信小程序--你所遇见的秘密

微信小程序,微你所微,信你所信! 微信小程序刚出不久,搞的世界一夜之间就像宝强哥一样闹得翻天覆地,打的是不可开交,然后说对是对,说错是错的铺天盖地,不知道是利国利民,还是人云亦云,随他们说去吧! ...
  • chajinglong
  • chajinglong
  • 2017年02月06日 14:45
  • 349

小视图有大秘密

视图,是什么nie,在我们小学的时候,就接触过视图的概念,那时候天还是那么蓝,云还是那么潇洒,给定一个立体图形,让小伙伴画出这个图形的三视图,即---主视图,俯视图,左视图,时过境迁,她再一次出现在我...
  • u010850027
  • u010850027
  • 2014年07月26日 17:59
  • 2500

1、微信小程序笔记---框架

由于传播面积更广,所以我的文章会优先发布在今日头条里,有兴趣的朋友可以去我的今日头条号查看,第一时间更新。1、单例的app:一个小程序必须有且只有一个app.xx。并且在根目录下。 app.js:相当...
  • yangzhenyutmac
  • yangzhenyutmac
  • 2016年10月30日 15:42
  • 397

浅谈常见设计模式--单例模式 简单工厂模式

今题那站在这里和大家一起分享最近在一本书上看到的关于设计模式的内容,接下来要讲的设计模式有: 单例模式 简单工厂模式 工厂方法和抽象工厂 代理模式 命令模式 策略模式 门面模式 桥接模式 观察者模式 ...
  • xikai18827083487
  • xikai18827083487
  • 2016年11月13日 17:04
  • 969

小类型向大类型转换

------------siwuxie095             在Java数值运算中,经常会出现不同的类型的数据相互转换的现象。        b1+10 赋值给 b2,Java默认整...
  • siwuxie095
  • siwuxie095
  • 2017年03月11日 16:38
  • 319

java面试题:java中的单例设计模式及两种实现方法的代码举例

java面试时经常会问到关于单例设计模式,因为它能考察的知识点较多且在开发中经常用到。 那我就来说一说我对于单例设计模式的一些浅见。 首先,在Java中,什么是单例呢? 就是保证类在内存中只有一...
  • qq_24693837
  • qq_24693837
  • 2016年11月23日 20:49
  • 1087
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:(转) 设计模式——小单例有大秘密
举报原因:
原因补充:

(最多只允许输入30个字)