设计模式之单例模式

• 饿汉式

package singleton;

/**
 * @author coffee
 * @Date 2021-04-08 17:12
 */
public class EHanShi {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }

}

/**
 * 饿汉式之静态常量
 */
class Singleton{
    private Singleton() {
    }
    private final static Singleton instance = new Singleton();//属性初始化

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

/**
 * 饿汉式静态代码块
 */
class Singleton1{
    public Singleton1() {
    }
    private static Singleton1 instance;
    {
        instance = new Singleton1();//静态代码块初始化
    }
    public static Singleton1 getInstance(){
        return instance;
    }
}

• 懒汉式

package singleton;

/**
 * @author coffee
 * @Date 2021-04-08 17:22
 */
public class LanHanShi {
    public static void main(String[] args) {
        System.out.println(SingletonOfLazy.getInstance().hashCode());
        System.out.println(SingletonOfLazy.getInstance().hashCode());
    }
}

/**
 * 懒汉式之双重检查线程安全
 * 推荐使用
 */
class SingletonOfLazy2{
    private static volatile SingletonOfLazy2 instance;
    private SingletonOfLazy2(){}


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

/**
 * 懒汉式之线程不安全
 * 实际开发中不使用
 */
class SingletonOfLazy{
    private static SingletonOfLazy instance;
    private SingletonOfLazy(){}
    public static SingletonOfLazy getInstance(){
        if (instance == null){
            instance = new SingletonOfLazy();
        }
        return instance;
    }
}

/**
 * 懒汉式之线程安全
 * 效率低，不推荐使用
 */
class SingletonOfLazy1{
    private static SingletonOfLazy1 instance;
    private SingletonOfLazy1(){}
    public static synchronized SingletonOfLazy1 getInstance(){
        if (instance == null){
            instance = new SingletonOfLazy1();
        }
        return instance;
    }
}

• 静态内部类

package singleton;

/**
 * 静态内部类实现单例模式
 * 推荐使用
 * @author coffee
 * @Date 2021-04-08 17:38
 */
public class StaticInternalClass {
    private static volatile StaticInternalClass instance;
    private StaticInternalClass(){}

    private static class SingletonInstance{
        private static final StaticInternalClass INSTANCE = new StaticInternalClass();
    }
    public static synchronized StaticInternalClass getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

• 枚举类

package singleton;

/**
 * 枚举类实现单例模式
 * 推荐使用
 * @author coffee
 * @Date 2021-04-08 17:44
 */
public enum Enum {

    INSTANCE;

    public void sayOK(){
        System.out.println("ok");
    }
}