设计模式-单例模式

        单例模式：确保一个类在任何情况下只有一个实例，并提供一个访问它的全局访问点。单例模式的是将构造方法设置成私有。

 这里提供单例模式的几种实现：

1. 饿汉式

        不管是否用到，类装载之初就完成了实例化，优点是类加载到内存后，实例化一个，由JVM保证线程安全，缺点是浪费内存。代码实现如下：

package singleton;

/**
 * 饿汉式
 * JVM保证线程安全
 */
public class Singleton {

    /**
     * 定义一个静态的实例，确保单例模式中有一个实例
     * */
    private static final Singleton INSTANCE = new Singleton();

    /**
     * 定义一个私有的构造方法
     * */
    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }
    
}

2. 懒汉式

2.1 懒汉式

        先定义一个实例，需要用到的时候在进行初始化，但是懒汉式存在线程不安全的问题，使用时需要搭配线程来使用。代码实现如下：

package singleton;

/**
 * 懒汉式
 */
public class Singleton {
    /**
     *  定义一个静态实例，但不进行初始化
     * */
    private static Singleton INSTANCE;

    private Singleton(){}

    /**
     *  在调用getINSTANCE方法时，对INSTANCE进行判空，如果INSTANCE为空，则对INSTANCE进行初始化
     * */
    private static Singleton getInstance(){
        if(INSTANCE == null){
            //使用线程让其等待，避免其多个线程出现同时实例化INSTANCE
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

2.2 双重判空+synchronized锁

         采用这种方式需要注意在定义INSTANCE对象时，需要用volatile关键字来防止指令重排，代码如下所示：

package singleton;

/**
 * 饿汉式
 * 采用双重判空方法，增加synchronized锁来控制线程安全
 */
public class Singleton {
    /**
     * 必须采用volatile关键字来防止指令重排
     * */
    private static volatile Singleton INSTANCE;

    private Singleton(){}
    /**
     * 采用双重判空检查来保证一个实例化对象
     * */
    public static Singleton getInstance(){
        if (INSTANCE == null){
            //使用synchronized锁来保证线程安全，但是效率会下降
            synchronized (Singleton.class){
                if (INSTANCE == null){
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

3. 静态内部类的方式

         JVM保证单例的线程安全，当只有调用getInstance()，实例才会初始化，如果只是单纯的加载外部类，是不会加载静态内部类。代码实现如下：

package singleton;

/**
 * 静态内部类方式
 */
public class Singleton {
    
    public Singleton (){}

    /**
     * 在Singleton定义一个静态的内部类
     * */
    public static class SingleClass{
        private final static Singleton INSTANCE = new Singleton();
    }

    /**
     *  定义一个getInstance方法，返回静态内部类中的实例化对象INSTANCE
     * */
    public static Singleton getInstance(){
        return SingleClass.INSTANCE;
    }
}

4. 枚举方法的单例模式

         枚举类没有构造方法,可以有效的解决线程同步、防止反序列化问题。代码实现如下：

package singleton;


public enum SingletonEnum {

    INSTANCE;

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(SingletonEnum.INSTANCE.hashCode());
            }).start();
        }
    }
}