单例模式
第一种 饿汉式
优点：执行效率高，性能高，没有任何的锁
缺点：某些情况下，可能会造成内存浪费
/**
* @author LionLi
*/
public class HungrySingleton {
private static final HungrySingleton hungrySingleton = new HungrySingleton();
private HungrySingleton(){
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
}
测试用例与结果
/**
* @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();
}
}
测试符合预期 不同线程下的实例是单例的
