单例设计模式

为了保证整个代码在操作的过程中，只会存在唯一的一个实例化对象，并且不可更改，则可利用final申明。

• 饿汉式单例模式

    public final static Singleton singleton =  new Singleton(); // static final 修饰变量
    private Singleton() {} //私有化构造方法
    public static Singleton getInstance() { // 对外提供一个public方法
        return singleton;
    }

• 懒（饱）汉式单例模式

    public static Singleton singleton=null; // 申明变量
    private Singleton() {  }
    public static synchronized Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton(); // 实例化对象
        }
        return singleton;
    }

特点： 懒加载启动快，资源占用少，使用时才实例化。

• 懒汉式-双重加锁检查DCL（Dubble Check Lock）

/**
 * 懒汉式 双重加锁检查DCL（double check lock）
 * 特点：
 *  1.实例必须有 volatile 关键字修饰，其保证初始化完全
 *  2.懒加载，线程安全。
 */
public class Animal {
    //对保存实例的变量添加volatile的修饰
    private static volatile Animal animal;
    private Animal() { }
    public static Animal getInstance() {
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if (animal == null) {
            //同步块，线程安全的创建实例
            synchronized (Animal.class) {
                if (animal == null) {
                    //再次检查实例是否存在，如果不存在才真的创建实例
                    animal = new Animal();
                }
            }
        }
        return animal;
    }
}

• Holder 模式

/**
 * Holder模式
 * 优点：将懒加载和线程安全完美结合的一种方式（无锁）。（推荐）
 */
public class Phone {

    /**
     * 私有化构造方法
     */
    private Phone() { }

    public static Phone getInstance(){
        return PhoneHolder.phone;
    }

    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class PhoneHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Phone phone = new Phone();
    }

}

多例设计

场景：

• 描述一周时间数的类，只能有7个对象
• 描述性别的类，只能有2个。
  多例是单例的衍生。