单例模式

一、含义：保证一个类只有一个实例，并提供一个访问它的全局访问点。

二、实现思路

（1）私有化构造方法

（2）类内部构建实例

（3）提供一个共有的静态方法，返回对象实例

三、七种实现代码

（1）饿汉式（静态常量）

// 优点：类装载的时候就实例化了，避免了线程同步问题
// 缺点：如果没有用到就会造成内存浪费
// 结论：在开发中可以使用，但可能会造成内存浪费
public class SingletonHungry{
    //1、私有化构造器
    private SingletonHungry() {
    }
    //2、 类内部创建对象实例
    private final static SingletonHungry instance=new SingletonHungry() ;
    //3、提供一个公有的静态方法，返回实例对象
    public static SingletonHungry getInstance() {
        return instance;
    }
}

（2）饿汉式（静态代码块）

// 优点：类装载的时候就实例化了，避免了线程同步问题
// 缺点：如果没有用到就会造成内存浪费
// 结论：在开发中可以使用，但可能会造成内存浪费
public class SingletonHungry {
    //1、私有化构造器
    private SingletonHungry() {
    }
    //2、 类内部创建对象实例
    private final static SingletonHungry instance ;
    static  { //在静态代码块中加载
        instance = new SingletonHungry();
    }
    //3、提供一个公有的静态方法，返回实例对象
    public static SingletonHungry getInstance() {
        return instance;
    }
}

（3）懒汉式（线程不安全）

// 优点：使用的时候才创建，不会造成内存浪费
// 缺点：多线程环境下可能会创建多个
// 结论：在开发中不使用。
public class SingletonLazy {

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

（4）懒汉模式（synchronized）

// 优点：线程安全了
// 缺点：效率太低
// 结论：开发中不推荐使用
public class SingletonLazy {
    private SingletonLazy() {}
    private static SingletonLazy instance;

    public static synchronized SingletonLazy getInstance() {
        if (instance ==null) {
            instance = new SingletonLazy();
        }
        return instance;

    }
}

（5）懒汉式（双重检查）

//懒汉式 双重检查
// 优点： 解决了线程同步和效率的问题
// 结论：推荐使用
/**
 * 注意：
 *   如果不用volatile关键字可能会产生异常，因为
 *        instance=new SingletonLazy()并不是原子操作，它分为三个部分
 *           1、为对象分配内存空间
 *           2、初始化对象
 *           3、instance指向内存空间
 *        在编译器运行时可能会出现指令重排，132,此时可能会造成返回一个未初始化的对象。
 *
 *        加 volatile是为了防止指令重排
 */
public class SingletonLazy {
    private SingletonLazy() {}

    private static volatile SingletonLazy instance;

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

（6）懒汉模式 静态内部类

/**
 * 静态内部类的特点：
 *   1、在SingletonStaticClass加载时不会加载（避免了内存浪费）
 *   2、加载时是线程安全的。
 *   结论：推荐使用
 */

public class SingletonStaticClass {
    private SingletonStaticClass() {

    }
    private static class SingletonStaticClassInstance{
        private static final SingletonStaticClass instance = new SingletonStaticClass();
    }
    public static SingletonStaticClass getInstance() {
        return SingletonStaticClassInstance.instance;
    }
}

（7）枚举

//不仅可以解决多线程与内存浪费的问题。还可以防止返序列化创建新的对象
//结论：推荐使用
enum SingletonEnum {
    INSTANCE;
        public SingletonEnum getInstance(){
        return INSTANCE;
    }
}