【设计模式】单例模式

优点：

• 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，单例模式的优势就非常明显。
• 当一个对象的产生需要比较多的资源时，比如读取配置，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。
• 单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

缺点：

• 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
• 单例对象如果持有Context，那么很容易引发内存泄露，此时需要注意传给单例对象的Context最好是Application Context。

---

代码示例：

饿汉式单例

• 饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

懒汉式单例

• 而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例，多线程可能有线程安全问题

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
} 

上列代码懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式。

一. DCL（Double Check Lock 双端检锁机制）

• DCL机制能保证多线程环境下99.99%情况线程安全，但是还存在0.01%线程不安全。

 // 此处使用valotile起到禁止指令重排的作用，可以保证DCL线程安全。
    private static volatile SingletonDemoTwo instance = null;
    public static SingletonDemoTwo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemoTwo.class) {
                if (instance == null) {
                    instance = new SingletonDemoTwo();
                }
            }
        }
        return instance;
    }

二. 在方法上加同步

public static synchronized Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
    }  

三. 静态内部类

public class Singleton {    
    private static class LazyHolder {    
       private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}

• 最后一种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。