单例模式
第一种 饿汉式
优点:执行效率高,性能高,没有任何的锁
缺点:某些情况下,可能会造成内存浪费
/** * @author LionLi */public class HungrySingleton {private static final HungrySingleton hungrySingleton = new HungrySingleton();private HungrySingleton(){}public static HungrySingleton getInstance(){returnhungrySingleton;}}
测试用例与结果
/** * @author LionLi */public class Test {public static void main(String[] args){ExecutorService executor = Executors.newFixedThreadPool(5);PrintStream out = System.out;executor.execute(() -> out.println(HungrySingleton.getInstance()));executor.execute(() -> out.println(HungrySingleton.getInstance()));executor.execute(() -> out.println(HungrySingleton.getInstance()));executor.execute(() -> out.println(HungrySingleton.getInstance()));executor.execute(() -> out.println(HungrySingleton.getInstance()));executor.shutdown();}}
多次运行符合要求不会出现问题
第二种 懒汉式
优点:节省了内存,线程安全
缺点:性能低
测试用例以下通用
/** * @author LionLi */public class Test {public static void main(String[] args){ExecutorService executor = Executors.newFixedThreadPool(5);PrintStream out = System.out;executor.execute(() -> out.println(LazySingletion.getInstance()));executor.execute(() -> out.println(LazySingletion.getInstance()));executor.execute(() -> out.println(LazySingletion.getInstance()));executor.execute(() -> out.println(LazySingletion.getInstance()));executor.execute(() -> out.println(LazySingletion.getInstance()));executor.shutdown();}}
第一版本
/** * @author LionLi */public class LazySingletion {private static LazySingletion instance;private LazySingletion(){}public static LazySingletion getInstance(){if(instance == null){instance = new LazySingletion();}return instance;}}
测试失败无法保证单例
第二版本 增加 synchronized 锁
/** * @author LionLi */public class LazySingletion {private static LazySingletion instance;private LazySingletion(){}public synchronized static LazySingletion getInstance(){if(instance == null){instance = new LazySingletion();}return instance;}}
测试成功 可以保证单例 但性能较低 所有的线程全都被阻塞到方法外部排队处理
第三版本 细化锁 只锁创建方法提高性能
优点: 性能高了,线程安全了
缺点:可读性难度加大,不够优雅
此方法在各大开源框架源码内最为常见 又名双重校验单例
/** * @author LionLi */public class LazySingleton {/** * volatile 保证原子性具体用法百度 */private volatile static LazySingleton instance;private LazySingleton(){}public static LazySingleton getInstance(){// 检查实例是否已经初始化 如果已经初始化直接返回 避免进入锁提高性能if (instance == null) {synchronized (LazySingleton.class) {// 重新检查是否已经被其他线程初始化if (instance == null) {instance = new LazySingleton();}}}return instance;}}
测试成功 可以保证单例 性能还高 可以避免不必要的加锁
第三种 枚举单例
在这种实现方式中,既可以避免多线程同步问题,还可以防止通过反射和反序列化来重新创建新的对象。
Java虚拟机会保证枚举对象的唯一性,因此每一个枚举类型和定义的枚举变量在JVM中都是唯一的。
/** * @author LionLi */public enum EnumSingleton {INSTANCE;private Object data;public Object getData() {return data;}public void setData(Object data) {this.data = data;}}
测试代码与结果
/** * @author LionLi */public class Test {public static void main(String[] args){ExecutorService executor = Executors.newFixedThreadPool(5);PrintStream out = System.out;// 设置一个对象便于查看内存地址EnumSingleton.INSTANCE.setData(new Object());executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));executor.shutdown();}}
测试成功 可以保证单例 代码简单非常优雅
第四种 Spring中的单例模式实现 也可以称为 容器化单例
大家可以通过idea搜索找到 Spring
源码中的 DefaultSingletonBeanRegistry
类 getSingleton
方法 查看 Spring
是如何编写的
这里涉及到三个单例容器:
- singletonObjects
- earlySingletonObjects
- singletonFactories
单例的获取顺序是
singletonObjects -> earlySingletonObjects -> singletonFactories
这样的三级缓存
我们发现,在
singletonObjects
中获取bean
的时候,没有使用synchronized
关键字而在
singletonFactories
和earlySingletonObjects
中的操作都是在synchronized
代码块中完成的,正好和他们各自的数据类型对应
singletonObjects
使用的使用ConcurrentHashMap
线程安全,而singletonFactories
和earlySingletonObjects
使用的是HashMap
线程不安全。
从字面意思来说:
singletonObjects
指单例对象的缓存,singletonFactories
指单例对象工厂的缓存,earlySingletonObjects
指提前曝光的单例对象的缓存。以上三个构成了三级缓存,
Spring
就用这三级缓存巧妙的解决了循环依赖问题。
除了这三个缓存之外 最核心的就是上面讲到的
双重校验单例
写法
第五种 特殊单例 线程单例
顾名思义 保证在所有线程内的单例
常见使用场景 日志框架 确保每个线程内都有一个单例日志实例 保证日志记录和输出的唯一性
提到线程 我们肯定会想到 在线程内最常使用的东西 那就是
TheadLocal
他可以保证线程之间的变量隔离 我们就基于他来实现线程单例
public class ThreadLocalSingleton {// 通过 ThreadLocal 的初始化方法 withInitial 初始化对象实例 保证线程唯一private static final ThreadLocal<ThreadLocalSingleton> threadLocaLInstance =ThreadLocal.withInitial(() -> new ThreadLocalSingleton());private ThreadLocalSingleton(){}public static ThreadLocalSingleton getInstance(){return threadLocaLInstance.get();}}
测试用例与运行结果
/** * @author LionLi */public class Test {public static void main(String[] args){ExecutorService executor = Executors.newFixedThreadPool(5);PrintStream out = System.out;executor.execute(() -> {out.println(ThreadLocalSingleton.getInstance());out.println(ThreadLocalSingleton.getInstance());});executor.execute(() -> {out.println(ThreadLocalSingleton.getInstance());out.println(ThreadLocalSingleton.getInstance());});executor.shutdown();}}
测试符合预期 不同线程下的实例是单例的