在某个类或者整个系统中只能有一个实例对象可被获取和使用的代码模式

一、要素

只能有一个实例
- 构造器私有化
必须自己创建自己这个实例
- 还有一个该类的静态变量来保存这个唯一的实例对象
必须自行向整个系统提供这个实例
- 对外提供获取该实例对象的方式（直接暴露、提供get方法）
  二、几种常见形式
  - 饿汉式：直接创建对象，不存在线程安全问题
    - 直接实例化饿汉式（简洁直观）
    - 枚举式（最简洁）
    - 静态代码块饿汉式（适合复杂实例化）
  - 懒汉式：延迟创建对象
    - 线程不安全（适用于单线程）
    - 线程安全（适用于多线程）
    - 静态内部类形式（适用于多线程）

1、饿汉式

直接实例化饿汉式

/**
 * @description:
 * 饿汉式：直接创建，不管你需不需要
 * @Author: wangchao
 * @Date: 2021/7/11
 */
public class Singleton1 {
    public static final Singleton1 SINGLETON = new Singleton1();
    private Singleton1() {
    }
}

测试

public class Test1 {
    public static void main(String[] args) {
        Singleton1 singleton1 = Singleton1.SINGLETON;
        System.out.println(singleton1);
    }
}

枚举式（最简洁）

/**
 * @description:
 * 枚举类型：表示该类型的对象是有限的几个，我们可以限定为一个，就成了单例
 * @Author: wangchao
 * @Date: 2021/7/11
 */
public enum Singleton2 {
    SINGLETON
}

测试

public class Test2 {
    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.SINGLETON;
        System.out.println(singleton2);
    }
}

静态代码块饿汉式（适合复杂实例化）

public class Singleton3 {
    public static final Singleton3 SINGLETON;
    private String info;
    static {
        try {
            Properties properties = new Properties();
            properties.load(Singleton3.class.getClassLoader().getResourceAsStream("singleton.properties"));
            SINGLETON = new Singleton3(properties.getProperty("info"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    private Singleton3(String info) {
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
}

测试

public class Test3 {
    public static void main(String[] args) {
        Singleton3 singleton3 = Singleton3.SINGLETON;
        System.out.println(singleton3.getInfo());
    }
}

2、懒汉式

线程不安全（适用于单线程）

public class Singleton4 {
    private static Singleton4 singleton;
    private Singleton4() {
    }
    public static Singleton4 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton4();
        }
        return singleton;
    }
}

测试01

// 简单测试
public class Test4 {
    public static void main(String[] args) {
        Singleton4 singleton = Singleton4.getSingleton();
        Singleton4 singleton2 = Singleton4.getSingleton();
        System.out.println(singleton);
        System.out.println(singleton2);
    }
}
结果 是同一个对象
com.supkingx.base.b_singleton.Singleton4@5cad8086
com.supkingx.base.b_singleton.Singleton4@5cad8086

测试02

// 展示线程不安全
public class Singleton4 {
    private static Singleton4 singleton;
    private Singleton4() {
    }
    public static Singleton4 getSingleton() {
        if (singleton == null) {
            try {
                // 为了展示线程不安全，这是睡眠100ms
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new Singleton4();
        }
        return singleton;
    }
}
public class Test4_1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Singleton4> callable = new Callable<Singleton4>() {
            @Override
            public Singleton4 call() throws Exception {
                return Singleton4.getSingleton();
            }
        };
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<Singleton4> submit1 = executorService.submit(callable);
        Future<Singleton4> submit2 = executorService.submit(callable);
        System.out.println(submit1.get());
        System.out.println(submit2.get());
    }
}
结果，不是同一个对象了
com.supkingx.base.b_singleton.Singleton4@5e2de80c
com.supkingx.base.b_singleton.Singleton4@1d44bcfa

线程安全（适用于多线程）

ps：这种写法也存在一定的风险：具体可以参考： https://www.yuque.com/wangchao-volk4/fdw9ek/zqskg7

public class Singleton5 {
    private static Singleton5 singleton;
    private Singleton5() {
    }
        // DCL (double check lock双端检索机制)，但是这种写法也不是最完美的写法，存在风险（指令重排），详细可见包 com.supkingx.base.f_thread.VolatileDemo，或者第十七章中关于volatile的介绍
    public static Singleton5 getSingleton() {
        // 外层的这个判断完全是为了性能考虑
        if (singleton == null) {
            // 与Singleton4线程不安全锁区别，加了synchronized后线程安全
            synchronized (Singleton5.class) {
                if (singleton == null) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    singleton = new Singleton5();
                }
            }
        }
        return singleton;
    }
}
// 测试
public class Test5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Singleton5> callable = new Callable<Singleton5>() {
            @Override
            public Singleton5 call() throws Exception {
                return Singleton5.getSingleton();
            }
        };
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<Singleton5> submit1 = executorService.submit(callable);
        Future<Singleton5> submit2 = executorService.submit(callable);
        System.out.println(submit1.get());
        System.out.println(submit2.get());
    }
}
结果
com.supkingx.base.b_singleton.Singleton5@5e2de80c
com.supkingx.base.b_singleton.Singleton5@5e2de80c

静态内部类形式（适用于多线程）

/**
 * @description: 懒汉式
 * 在内部类被加载和初始化时，才创建SINGLETON实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独加载和初始化的。
 * 因为是在内部类加载和初始化时创建的，所以是线程安全的。
 * @Author: wangchao
 * @Date: 2021/7/11
 */
public class Singleton6 {
    private Singleton6() {
    }
    private static class Inner {
        private static final Singleton6 SINGLETON = new Singleton6();
    }
    private static Singleton6 getInstance() {
        return Inner.SINGLETON;
    }
}
// 测试
public class Test6 {
    public static void main(String[] args) {
        Singleton6 singleton = Singleton6.getInstance();
        System.out.println(singleton);
    }
}

3、对以上所有写法的优化

如上所述会出现指令重排的风险，所以需要加上volatile
1-Volatile

private static volatile SingletonDemo3 singletonDemo = null;

至此，volatile避免指令重排，synchronized保证了原子性，完美。

三、总结

如果是饿汉式，枚举形式最简单
如果是懒汉式，静态内部类形式最简单

设计模式

单例模式

一、要素

二、几种常见形式

1、饿汉式

直接实例化饿汉式

枚举式（最简洁）

静态代码块饿汉式（适合复杂实例化）

2、懒汉式

线程不安全（适用于单线程）

线程安全（适用于多线程）

静态内部类形式（适用于多线程）

3、对以上所有写法的优化

三、总结