单例模式和双重检测的小结

2022-03-17 08:35:47

设计模式的经典模式之一——单例模式

这个也是面试经常被问起的面试，一般都要求手写

【饿汉模式】非延时加载 ——以空间换时间

【懒汉模式】延时加载——以时间换空间

看似简单，但是在懒汉模式还隐藏了一个双重检测，其中还是涉及到JVM内存的“无序写入”问题（后面使用的 volatile ）


1、饿汉模式

比较简单，非延时加载，一上来就把对象给new出来了

[java] view plain copy
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">public class Singleton {  
  2.     private Singleton(){} //默认构造器  
  3.     private static Singleton instance = new Singleton();//直接加载  
  4.     public Singleton getIntance(){  
  5.         return instance;  
  6.     }  
  7. }</span>  

2、懒汉模式，延时加载

【1】普通

[java] view plain copy
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">public class Singleton {  
  2.     private Singleton() { } // 默认构造器  
  3.   
  4.     private static Singleton instance = null;// 延时加载  
  5.     //每次运行都要创建实例因而需要加锁保护  
  6.     public static synchronized Singleton getIntance() {  
  7.         if (instance == null) {  
  8.             instance = new Singleton();// 判断之后加载  
  9.         }  
  10.         return instance;  
  11.     }  
  12.   
  13. }</span>  

【2】双重检测（有缺陷来自JVM自身）

上面尽管这样做到了线程安全，并且解决了多实例问题，但并不高效。在任何调用这个方法的时候，你都需要承受同步带来的性能开销，然而同步只在第一次调用的时候才被需要，也就是单例类实例创建的时候。这将促使我们使用双重检查锁模式（double checked locking pattern），一种只在临界区代码加锁的方法。一般称其为双重检查锁，因为会有两次检查 _instance == null，一次不加锁，另一次在同步块上加锁。

[java] view plain copy
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">public class Singleton {  
  2.     private Singleton() { } // 默认构造器  
  3.   
  4.     private volatile static Singleton instance = null;// volatile 可见性/防止重排序  
  5.   
  6.     public static Singleton getIntance() {  
  7.         // 第一重判断  
  8.         if (instance == null) {  
  9.             // 锁定代码块  
  10.             synchronized (Singleton.class) {  
  11.                 // 第二重判断  
  12.                 if (instance == null) {  
  13.                     instance = new Singleton();// 判断之后加载  
  14.                 }  
  15.   
  16.             }  
  17.   
  18.         }  
  19.         return instance;  
  20.     }  
  21.   
  22. }</span>  
如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量instance之前增加修饰符volatile（可见性，防止重排序），被volatile修饰的成员变量可以确保多个线程都能够正确处理，且该代码只能在JDK 1.5及以上版本中才能正确执行。

【3】ThreadLocal模式的单例

[java] view plain copy
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">    public class Singleton{    
  2.       public static final ThreadLocal  threadInstance=new ThreadLocal();    
  3.      public static Singleton singleton=null;    
  4.       public static getSingleton(){    
  5.          if(threadInstance.get()==null){    
  6.              createSingleton();    
  7.           }    
  8.       }    
  9.       public static Singleton createSingleton(){    
  10.          synchronized(Singleton.class){    
  11.            if(singleton==null){    
  12.                 singleton=new Singleton();    
  13.             }    
  14.           }    
  15.       }    
  16.         
  17.     }   </span>  

ThreadLocal的全局变量局部化 第一次检测采用线程局部来做如果线程已经访问过则不需要进入同步块


转载：http://blog.csdn.net/xsf50717/article/details/47305203

上一篇：Java高新技术1---增强for循环 ---装箱与拆箱享元设计模式--自己写枚举--可变长度的参数


下一篇：一个内存增长问题的分析和处理（三）