码迷，mamicode.com
首页 > 编程语言 > 详细

再看JAVA 设计模式-单例【转】

时间：2015-01-23 10:46:37      阅读：197      评论：0      收藏：0      [点我收藏+]

标签：

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

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

 

[java] view plaincopyprint?
 
  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为空，接下来就会得到两个实例了。这不是我们想要的单例。

 

 

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

[java] view plaincopyprint?
 
  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()是线程互斥就可以保证线程安全，所以就有了下面这个版本：

[java] view plaincopyprint?
 
  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的初始化，再返回。 

 

难道就没有一个好方法了吗？好的方法肯定是有的，我们继续探索！

[java] view plaincopyprint?
 
  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实例。

 

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

[java] view plaincopyprint?
 
  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对象，这样带来的一个缺点就是：如果构造的单例很大，构造完又迟迟不使用，会导致资源浪费。

 

到底有没有完美的方法呢？继续看：

[java] view plaincopyprint?
 
  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();这句话是怎么执行的，下面用一段伪代码向大家解释一下：

 

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

 

 

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

再看JAVA 设计模式-单例【转】

标签：

原文地址：http://www.cnblogs.com/xiao-kkp/p/4243297.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！