单例模式解释

单例模式是一种对象创建性模式，该模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式三要素：

1. 某个类只能有一个实例
2. 必须自行创建整个实例
3. 必须自行向整个系统提供整个实例

英文定义：Ensure a class only has one instance, and provide a global point of access to it.

单例模式类图

单例模式类图

应用场景

1. 要求生成唯一序列号的环境
2. 在整个项目中需要一个共享访问点或共享数据，例如一个web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的
3. 创建一个对象需要消耗的资源过多，如要访问io和数据库资源等
4. 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）

单例模式写法

1. 私有化构造函数
2. 提供获取实例对象的静态方法

单例模式分类

饿汉式

/**
 * Created by zs on 2017/3/9.
 *
 * 单例模式- 饿汉式
 * 类加载的时候立即实例化，但是这种比较耗费资源
 */
public class Singleton {

    /** 类被加载进入内存的时候就创建单一的Singleton对象 */
    private static final Singleton singleton = new Singleton();

    /**
     * 构造函数私有化，限制产生多个对象
     */
    private Singleton(){}

    /**
     * 通过该方法获得实例对象
     *
     * @return 实例对象
     */
    public static Singleton getSingleton(){
        return singleton;
    }
}

说明：饿汉式线程安全，但不能实现延迟加载

懒汉式

/**
 * Created by zs on 2017/3/9.
 *
 * 单例模式- 懒汉式
 * 在需要使用的时候实例化对象
 */
public class Singleton {
    
    private static Singleton singleton;

    /**
     * 构造函数私有化，限制产生多个对象
     */
    private Singleton(){}

    /**
     * 通过该方法获得实例对象
     *
     * @return 实例对象
     */
    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

说明：懒汉式在单线程下能非常好的工作，但是在多线程下存在线程安全问题。如一个线程A执行到singleton = new Singleton(); 但还没有获得对象(对象初始化需要时间)，第二个线程B也在执行，执行到(singleton == null)判断，那么线程B获得判断条件也是为真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，在内存中就出现了两个对象。

懒汉式-线程安全

/**
 * Created by zs on 2017/3/9.
 *
 * 单例模式- 懒汉式
 * 解决多线程安全问题，采用了对函数进行同步的方式
 */
public class Singleton {

    private static Singleton singleton;

    /**
     * 构造函数私有化，限制产生多个对象
     */
    private Singleton(){}

    /**
     * 通过该方法获得实例对象,使用同步方法
     *
     * @return 实例对象
     */
    public static synchronized Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

说明：为解决多线程问题，采用了对函数进行同步的方式，但是比较浪费资源，因为每次都要进行同步检查，而实际中真正需要检查只是第一次实例化的时候，锁定的区域过大

懒汉式-线程安全优化

/**
 * Created by zs on 2017/3/9.
 *
 * 单例模式- 懒汉式
 * 多线程安全优化
 */
public class Singleton {

    private static Singleton singleton;

    /**
     * 构造函数私有化，限制产生多个对象
     */
    private Singleton(){}

    /**
     * 通过该方法获得实例对象
     *
     * @return 实例对象
     */
    public static Singleton getSingleton(){
        //第一重判断
        if(singleton == null){
            //锁定代码快
            synchronized (Singleton.class){
                //第二重判断
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

说明：解决了懒汉式的多线程问题，又解决了资源浪费的现象

静态内部类

/**
 * Created by zs on 2017/3/9.
 *
 * 单例模式-静态内部类式
 */
public class SingleInnerTask {

    /**
     * 在第一次被引用的时候被加载
     */
    private static class InnerHelper{
        private static final SingleInnerTask instance =
                         new SingleInnerTask();
    }
    /**
     * 构造函数私有化，限制产生多个对象
     */
    private SingleInnerTask(){}

    public static SingleInnerTask getInstance(){
        return InnerHelper.instance;
    }
}

说明：即实现了线程安全的单例，又避免了同步带来的性能影响

单例模式扩展

如果要求一个类只能产生两三个对象，这种需要产生固定数量对象的模式叫做有上限的多例模式 ---《设计模式之禅》

/**
 * Created by zs on 2017/3/9.
 * 
 * 有上限的多例模式
 */
public class Emperor {
    private static int maxNumOfEmperor = 2;
    private static ArrayList<Emperor> emperors = new ArrayList<>();

    static {
        for (int i = 0; i < maxNumOfEmperor; i++) {
            emperors.add(new Emperor("皇帝" + i));
        }
    }
    
    private Emperor(String name) {}

    public static Emperor getInstance() {
        Random random = new Random();
        int nextInt = random.nextInt(maxNumOfEmperor);
        return emperors.get(nextInt);
    }
}

优缺点

优点：

1. 客户端使用单例模式的实例，只需要调用一个单一的方法即可生成唯一的实例，有利于节约资源。
2. 允许可变数目的实例

缺点：

1. 单例模式没有抽象层，因此扩展困难，若要扩展，除非修改代码
2. 由于单例模式采用静态方法，无法在继承结构中使用。
3. 现在很多面向对象对象语言的垃圾回收机制，认为如果实例化的共享对象长时间没有被使用，系统会认为它是垃圾，会自动销毁并回收资源，下次使用又回重新实例化，这将导致共享的单例状态丢失