单例模式是设计模式中最常见也最简单的一种设计模式，保证了在程序中只有一个实例存在并且能全局的访问到。比如在Android实际APP 开发中用到的 账号信息对象管理， 数据库对象（SQLiteOpenHelper）等都会用到单例模式。下面针对一些例子分析一下我们在开发过程中应用单例模式需要注意的点。

一、作用
单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点

二、适用场景

1. 应用中某个实例对象需要频繁的被访问。

2. 应用中每次启动只会存在一个实例。如账号系统，数据库系统。

三、常用的使用方式

（1）懒汉式

这是在开发中很容易就能写出来的一种方式，如下

public class Singleton {
    //* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
    private static Singleton instance=null;
    
 /* 私有构造方法，防止被实例化 */  
    private Singleton(){
        
    }
   /* 1:懒汉式，静态工程方法，创建实例 */  
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }

}

优点：延迟加载（需要的时候才去加载）

缺点： 线程不安全，在多线程中很容易出现不同步的情况，如在数据库对象进行的频繁读写操作时。

（2）加同步锁

既然线程不安全，那就加上同步锁，一种加法如下：

[java] view plain copy

 

 

1. /*2.懒汉式变种，解决线程安全问题**/  
2.  public static synchronized Singleton getInstance() {  
3.      if (instance == null) {  
4.          instance = new Singleton();  
5.      }  
6.      return instance;  
7.  }  

更一般的写法是这样

[java] view plain copy

 

 

1. /*加上synchronized，但是每次调用实例时都会加载**/  
2.  public static Singleton getInstance() {  
3.      synchronized (Singleton.class) {  
4.          if (instance == null) {  
5.              instance = new Singleton();  
6.          }  
7.      }  
8.      return instance;  
9.  }  

调用：

[java] view plain copy

 

 

1. Singleton.getInstance().method();  

优点：解决了线程不安全的问题。

缺点：效率有点低，每次调用实例都要判断同步锁

补充：在Android源码中使用的该单例方法有：InputMethodManager，AccessibilityManager等都是使用这种单例模式

（3）双重检验锁

要优化（2）中因为每次调用实例都要判断同步锁的问题，很多人都使用下面的一种双重判断校验的办法

[java] view plain copy

 

 

1. /*3.双重锁定:只在第一次初始化的时候加上同步锁*/  
2.   public static Singleton getInstance() {  
3.       if (instance == null) {  
4.           synchronized (Singleton.class) {  
5.               if (instance == null) {  
6.                   instance = new Singleton();  
7.               }  
8.           }  
9.       }  
10.       return instance;  
11.   }  

这种方法貌似很完美的解决了上述效率的问题，它或许在并发量不多，安全性不太高的情况能完美运行，但是，这种方法也有不幸的地方。问题就是出现在这句

[java] view plain copy

 

 

1. instance = new Singleton();  

在JVM编译的过程中会出现指令重排的优化过程，这就会导致当 instance实际上还没初始化，就可能被分配了内存空间，也就是说会出现 instance !=null 但是又没初始化的情况，这样就会导致返回的 instance 不完整（可以参考：http://www.360doc.com/content/11/0810/12/1542811_139352888.shtml）。

调用：

[java] view plain copy

 

 

1. Singleton.getInstance().method();  

优点：在并发量不多，安全性不高的情况下或许能很完美运行单例模式

缺点：不同平台编译过程中可能会存在严重安全隐患。

补充：在android图像开源项目Android-Universal-Image-Loader （https://github.com/nostra13/Android-Universal-Image-Loader）中使用的是这种方式

（4）内部类的实现

内部类是一种好的实现方式，可以推荐使用一下：

[java] view plain copy

 

 

1. public class SingletonInner {  
2.   
3.     /** 
4.      * 内部类实现单例模式 
5.      * 延迟加载，减少内存开销 
6.      *  
7.      * @author xuzhaohu 
8.      *  
9.      */  
10.     private static class SingletonHolder {  
11.         private static SingletonInner instance = new SingletonInner();  
12.     }  
13.   
14.     /** 
15.      * 私有的构造函数 
16.      */  
17.     private SingletonInner() {  
18.   
19.     }  
20.   
21.     public static SingletonInner getInstance() {  
22.         return SingletonHolder.instance;  
23.     }  
24.   
25.     protected void method() {  
26.         System.out.println("SingletonInner");  
27.     }  
28. }  

调用：

[java] view plain copy

 

 

1. SingletonInner.getInstance().method();  

优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗