定义
单例模式（Singleton Pattern） 是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
特点
- 构造方法私有
- 提供一个全局的静态访问点
饿汉式-单例
它是在类加载的时候就立即初始化
静态变量初始化类
静态代码块初始化类
缺点
不管用不用都会初始化，浪费空间
优点
速度快，因为已经初始化了。
懒汉式-单例
在外部调用的时候才创建
双重检查
静态内部类方式(最完美) 不用的时候不会加载内部类
注册式单例 spring 用容器管理对象，返回单例
ThreadLocal单例
双重检查实现单例
public class ThreadPoolExecutorFactory {
//防止指令重排序导致的 对象没有初始化而被使用的问题
private static ThreadPoolExecutor threadPoolExecutor;
//防止用反射生成单例对象
private ThreadPoolExecutorFactory(){
if (null != threadPoolExecutor) {
throw new RuntimeException("不可用反射来生成对象 莫装逼");
}
}
public static ThreadPoolExecutor getInstance(){
//双重判断 主要是防止多线程环境下引起的并发的问题 + 效率问题
if (null == threadPoolExecutor) {
synchronized (ThreadPoolExecutorFactory.class) {
if (null == threadPoolExecutor) {
threadPoolExecutor = new SynThreadPoolExecutor(
10,
50,
10,
TimeUnit.MINUTES,
new ArrayBlockingQueue<>(8000),
new ThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
}
}
}
return threadPoolExecutor;
}
}
缺点
太复杂，为了解决静态单例模式中对象被优先初始化的问题。从而引入了诸如 多线程 指令重排序的多个问题。稍不注意就会导致问题。而且可读性不高。
为什么要加入volatile
实例化一个对象其实可以分为三个步骤：
（1）分配内存空间。
（2）初始化对象。
（3）将内存空间的地址赋值给对应的引用。
但是由于操作系统可以对指令进行重排序，所以上面的过程也可能会变成如下过程：
（1）分配内存空间。
（2）将内存空间的地址赋值给对应的引用。
（3）初始化对象
如果是这个流程，多线程环境下就可能将一个未初始化的对象引用暴露出来，从而导致不可预料的结果（如题目的描述，这里就是因为 threadPoolExecutor = new SynThreadPoolExecutor(); 不是原子操作，编译器存在指令重排，从而存在线程1 创建实例后（初始化未完成），线程2 判断对象不为空后对其操作，但实际对象仍为空，造成错误）。因此，为了防止这个过程的重排序，我们需要将变量设置为volatile类型的变量，volatile的禁止重排序保证了操作的有序性。而volatile之所以能够起作用是因为这个关键字调用了服务器提供的内存屏障指令。
静态内部类-单例
/**
* StaticInnerClassSingleton.class被加载后并不会加载
* StaticInnerClassSingleton$LazyHolder.class内部类，当被使用后
* 才会从虚拟中加载class文件进行初始化并分配内存且唯一
*
* ***/
public class StaticInnerClassSingleton {
private StaticInnerClassSingleton() {
}
public StaticInnerClassSingleton getInstance() {
return LazyHolder.instance;
}
//静态内部类
private static class LazyHolder {
private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
}
}
优点: 逻辑清晰，代码优化
缺点: 可以通过反射破坏单例
破坏单例模式-反射
public class test {
public static void main(String[] args) throws Exception {
//获取类文件class
Class<StaticInnerClassSingleton> staticInnerClassSingletonClass = StaticInnerClassSingleton.class;
//获取构造方法
Constructor<StaticInnerClassSingleton> constructor = staticInnerClassSingletonClass.getDeclaredConstructor(null);
//强吻
constructor.setAccessible(true);
//通过反射获取对象
StaticInnerClassSingleton staticInnerClassSingleton = constructor.newInstance();
System.out.printf(staticInnerClassSingleton + "");
}
}
解决反射破坏单例模式
/**
* StaticInnerClassSingleton.class被加载后并不会加载
* StaticInnerClassSingleton$LazyHolder.class内部类，当被使用后
* 才会从虚拟中加载class文件进行初始化并分配内存且唯一
*
* ***/
public class StaticInnerClassSingleton {
private StaticInnerClassSingleton() {
if (LazyHolder.instance != null) {
throw new RuntimeException("不可以通过反射方式创建单例对象");
}
}
public StaticInnerClassSingleton getInstance() {
return LazyHolder.instance;
}
//静态内部类
private static class LazyHolder {
private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
}
}
注册式单例-枚举
public enum EnumSingleton {
//这就代表了一个枚举类
instance();
private final OkHttpClient okHttpClient;
EnumSingleton(){
okHttpClient = new OkHttpClient();
}
public static OkHttpClient getInstance(){
return instance.okHttpClient;
}
}
枚举式单例无法被反射破坏
Class<EnumSingleton> enumSingletonClass = EnumSingleton.class;
Constructor<EnumSingleton> declaredConstructor = enumSingletonClass.getDeclaredConstructor(String.class, int.class);
declaredConstructor.setAccessible(true);
EnumSingleton enumSingleton = declaredConstructor.newInstance();
System.out.print(enumSingleton);
班班老师.png
原因
Constructor
@CallerSensitive
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
....
//源码中写到了，如果是单例则抛出异常，这与上面自己写的防止破坏单例是一样的
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
...
T inst = (T) ca.newInstance(initargs);
return inst;
}
枚举为什么是单例的
public final class EnumSingleton extends Enum {
//关注这一行，这里很明显是单例模式的懒汉式的写法，直接创建这个对象，无论你是否需要
public static final EnumSingleton INSTANCE = new EnumSingleton("INSTANCE", 0);
// $FF: synthetic field
private static final EnumSingleton[] $VALUES = new EnumSingleton[]{INSTANCE};
public static EnumSingleton[] values() {
return (EnumSingleton[])$VALUES.clone();
}
public static EnumSingleton valueOf(String name) {
return (EnumSingleton)Enum.valueOf(EnumSingleton.class, name);
}
private EnumSingleton(String var1, int var2) {
super(var1, var2);
}
容器化单例
其实就是spring中的ioc容器。相当于在系统内部维护了一个集合Map，map中存储了对象的实例。
反序列化破坏单例
定义单例对象
一定要实现序列化接口，不然无法序列化
public class StaticSingleton implements Serializable {
private StaticSingleton() {
}
private static final StaticSingleton instance = new StaticSingleton();
public static StaticSingleton getInstance(){
return instance;
}
}
通过反序列化生成对象
public static void main(String[] args) throws Exception {
StaticSingleton s1 = null;
StaticSingleton s2 = StaticSingleton.getInstance();
//获取单例对象，然后序列化到文件中
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("static.obj"));
objectOutputStream.writeObject(s2);
objectOutputStream.flush();
objectOutputStream.close();
//反序列化对象
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("static.obj"));
s1 = (StaticSingleton) objectInputStream.readObject();
objectInputStream.close();
//false
System.out.println(s1 == s2);
}
解决反序列破坏单例对象的问题
public class StaticSingleton implements Serializable {
private StaticSingleton() {
}
private static final StaticSingleton instance = new StaticSingleton();
public static StaticSingleton getInstance(){
return instance;
}
//在单例的类中添加这个对象 防止反序列破坏对象
private Object readResolve() {
return instance;
}
}
再次执行反序列化方法
image-20201120163354909.png
原理
ObjectInputStream
这里的大体意思是如果对象定义了readResolve方法，那么反序列化的时候就会返回readResolve方法中的对象,并不会进行实例化一个新的对象。
image-20201120163803374.png
ThreadLocal 单例-- 局限性单例
ThreadLocal 因为是每个线程都拥有一个自己的map，map中维护了对象的实例。所以天生就是线程安全的。但是出了自己的线程就不是单例的了。
