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

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

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

[java] view plaincopyprint?

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

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

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

[java] view plaincopyprint?

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

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

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

[java] view plaincopyprint?

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

这次看起来既解决了线程安全问题，又不至于每次调用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. private static Singleton instance = null;
  5. //私有化的构造方法，保证外部的类不能通过构造器来实例化
  6. private Singleton() {}
  7. //获取单例对象实例
  8. public static Singleton getInstance() {
  9. if (instance == null) {
  10. synchronized (Singleton.class) {                  //1
  11. Singleton temp = instance;                //2
  12. if (temp == null) {
  13. synchronized (Singleton.class) {  //3
  14. temp = new Singleton();   //4
  15. }
  16. instance = temp;                  //5
  17. }
  18. }
  19. }
  20. System.out.println("我是解决无序写懒汉式单例！");
  21. return instance;
  22. }
  23. }

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. ctorSingleton(instance);    //调用Singleton的构造函数，传递instance.

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

时间： 2024-10-11 07:22:57

再看JAVA 设计模式-单例【转】的相关文章

Java设计模式—单例设计模式(Singleton Pattern)全然解析

转载请注明出处:http://blog.csdn.net/dmk877/article/details/50311791 相信大家都知道设计模式,听的最多的也应该是单例设计模式,这种模式也是在开发中用的最多的设计模式,可能有非常多人会写几种设计模式.那么你是否知道什么是设计模式?为什么会有单例设计模式即它的作用是什么?单例模式有哪些写法?对于这种问题.可能有部分童鞋并不能非常好的回答,没关系今天就和大家一起来具体的学习下单例设计模式,相信通过学习本篇你将对单例设计模式有个具体的理解. 如有谬误欢

java设计模式--单例设计模式

java中共有21种设计模式,其中面试中常问的是单例设计模式: 单例设计模式有两种常用的方式:1.懒汉式:1)先私有化构造函数,让此类不能被实例化:(private 类名(){}):2)在类中自己实例化一个空的对象:(private static 类名  对象名=null;):3)构造一个方法,返回本类的对象:在中间增加一个判断语句,如果进来的对象是个空值,就new一个实例化,否则直接返回此对象: 例如: /** * 懒汉式 * @author chenjun *2017-5-2上午9:16:0

java设计模式--单例

GOF23(group of four)---由4个大牛总结的JAVA23种常用的设计模式,归根结底都是为了代码的可扩展性. 设计模式中一种比较重要的思想就是:开闭原则,尽量做到对扩展开放,对修改关闭. 单例模式:开发中最常见也是最简单的一种模式 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例.在计算机系统中,线程池.缓存.日志对象.对话框.打印机.显卡的驱动程序对象常被设计成单例. 1.懒汉式单例 //懒汉式单例类.在第一次调用的时候实例化自己,优点:延时加载,用到时候

Java设计模式——单例设计模式

单例设计模式 概述 ? 某个类有且只能有一个对象,如:用这个对象记录只有一个用户的信息 饿汉式 步骤 private构造方法 设计一个private static的当前类的对象,并new 提供一个static方法,返回一个当前类的对象 代码 /** * 单例模式 * 饿汉式 */ public class Program1 { public static void main(String args[]) { User user = User.getInstance(); //测试部分 for (

Java软件设计模式------单例设计模式

Java软件设计模式一共分为23种; 一般常用的有: 单例设计模式 装饰设计模式 工厂设计模式 单例设计模式(以后的用处:spring框架IOC,默认创建的对象都是单例的): 单例模式是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单例类的特殊类.通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源.如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案. 单例设计模式分为两种(饿汉式和懒汉式): ①饿汉式(常用): 特

java的单例设计模式(对象的延时加载)考试专用

java的单例设计模式(对象的延时加载) ,称为:懒汉式    考试专用例:package day6; public class Single2 {  //考试专用  ,对象的延时加载 ,外号:赖汉式        private static Single2 s=null;        private Single2(){            }        public static synchronized Single2 getInstance(){  //synchronized

Javascript 设计模式 单例

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/30490955 一直很喜欢Js,,,今天写一个Js的单例模式实现以及用法. 1.单例模式的写法 单例模式写法相当简单: var singleTon = { m1: "memeber first ", m2: "memeber second ", f1: function () { console.log("fun1 "); } }

java：单例的理解

前言:Java的单例经常用到,今天发现自己有一点新的认识. 懒汉式单例 package com.mwq.singleton; public class Singleton1 { private Singleton1() { } private static Singleton1 single = null; public static Singleton1 getInstance() { if (single == null) { return new Singleton1(); } retur

设计模式--单例

单例设计模式用来创建唯一的对象,有些时候我们只需要一个对象,如:线程池,缓存,对话框,注册表,日志对象,等等.这就需要单例设计模式来完成.不用多说,直接上代码.public class TestSingle { private static TestSingle single = null; private TestSingle(){} public static TestSingle getInstance(){ if(single==null){ single = new TestSingl