单例模式

1、定义

单例模式，属于创建类型的一种常用的设计模式。确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式关键点：
（1）单例类必须自己创建自己的唯一实例（私有的构造函数）
（2）单例类必须给所有其他对象提供这一实例（通过一个公共的静态方法或者枚举返回单实例对象）
（3）确保单例类的实例对象有且只有一个

2、优缺点

优点：

• 在内存中有且只有一个实例，避免频繁创建对象，减少了内存开支
• 避免对资源的多重占用，例如写文件操作，由于只有一个实例，可以避免同一个资源文件的同时写操作

缺点：

• 单例模式一般没有接口，扩展困难，一般只能修改，违背了开闭原则
• 在Android中，如果单例对象持有Context，容易引起内存泄漏，需要注意使用Application Context

3、单例模式的实现方式

（1）懒汉式（非线程安全）
lazy初始化，只在需要的时候才创建单实例对象。因为没有加锁 synchronized，所以在多线程下不能正常工作。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

（2）懒汉式（线程安全）
lazy初始化，只在需要的时候才创建单实例对象。使用synchronized进行加锁，虽然保证了多线程下的单例，但是加锁会影响效率。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

（3）饿汉式
基于 classloader 机制，在类加载的时候实例化单例对象，实现单例对象的唯一性和线程安全。
类加载的方式是按需加载，且只加载一次。因此，在单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。换句话说，在线程访问单例对象之前就已经创建好了。再加上，由于一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例，也就是说，线程每次都只能也必定只可以拿到这个唯一的对象。因此就说，饿汉式单例天生就是线程安全的。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

（4）双检锁/双重校验锁
因为有两次判空校验，所以叫双重校验锁，一次是在同步代码块外，一次是在同步代码块内。
第一个判空是为了减少性能开销，第二个判空是为了避免生成多个对象实例。
场景分析：
现有三个线程A，B，C，假设线程A和线程B同时调用getSingleton()时，判断第一层if判断都为空，这时线程A先拿到锁，线程B在代码块外层等待。线程A进行第二层if判断，条件成立后new了一个新对象，创建完成，释放锁，线程B拿到锁，进行第二层if判断，singleton不为空，直接返回singleton释放锁，避免生成多个对象实例。线程线C调用getSingleton时第一层判断不成立，直接拿到singleton对象返回，避免进入锁，减少性能开销。
volatile关键字修饰变量的作用是，保证每个线程在内存中获取到的变量是最新的。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

（5）登记式/静态内部类
这种方式和饿汉式原理一样，但是通过内部类的方式实现了懒加载的效果。当Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。

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

（6）枚举
枚举类编译后,所有的枚举变量都是static，基于 classloader 机制实现线程同步。
这是实现单例模式的最佳方法。它更简洁，不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}