标签：resolve private 允许 style 初始化 vat 深拷贝 volatil 地址空间
“学习的路上没有捷径，我是这样认为的...”
定义：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
所以需要隐藏构造方法。
属于创建型模式【有待查阅】
单例模式有点：
1. 内存中只有一个实例，减少内存开销
2. 避免对资源的多重占用 【不是很理解】
3. 严格控制访问
1.【饿汉式】
1 public class HungrySingleton { 2 private static final HungrySingleton hungrySingleton = new HungrySingleton(); 3 4 private HungrySingleton(){ 5 throw new RuntimeException("Don‘t Create");//防止通过其他途径去实例化对象 6 } 7 public HungrySingleton getInstance(){ 8 return hungrySingleton; 9 } 10 }
特点：1. 线程安全，
2. 在类加载的时候，就会将该类实例化，即便没有使用也会加载，导致资源浪费。
2.【懒汉式】
1 public class LazySingleton { 2 private LazySingleton(){ 3 throw new RuntimeException("Don‘t Create");//防止通过其他途径去实例化对象 4 } 5 private volatile static LazySingleton lazySingleton; 6 7 public static LazySingleton getInstance(){ 8 if(lazySingleton==null) { //该层判断只是优化让所有线程进来先进行判断， 9 //如果没有该判断，当该对象已经实例化了， 10 //但是【每个】线程进来都会等待同步锁，导致效率低 11 synchronized (LazySingleton.class) { 12 if (lazySingleton == null) { //该层判断只是为了当多个线程都走过了第一个判断 13 // 第一个线程已经初始化实例了 14 //防止后来的线程再次创建 15 lazySingleton = new LazySingleton(); 16 } 17 } 18 } 19 return lazySingleton; 20 } 21 }
特点：双重校验保证了效率和线程安全
注意：使用 【volatile】关键字的原因
第13行，new LazySingleton()，new一个对象，有4个步骤
1. 分配内存空间。
2. 初始化实例。
3. 返回地址引用。
cpu的指令重排序，可能会将2.3执行顺序打乱
接下来，通过一段伪代码来看下
1 instance = new SingletonDemo();//可以分为以下3步完成（伪代码） 2 memory = allocate(); // 1.分配内存对象空间 3 instance = (memory); // 2.初始化对象 4 instance = memory; // 3.设置instance指向刚分配的内存地址，此时instance != null 5 //由于步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变 6 //因此这种重排优化是允许的。 7 memory = allocate(); // 1.分配内存对象空间 8 instance = memory; // 3.设置instance指向刚分配的内存地址，此时instance != null， 9 // 【但是对象初始化没有完成，就相当于这个地址空间内没有实际的值。】 10 instance = (memory); // 2.初始化对象
volatile 可以禁止CPU指令重排序，从而避免这个问题。
3.静态内部类单例模式
1 public class LazyInnerClassSingleton { 2 private LazyInnerClassSingleton(){ 3 throw new RuntimeException("Don‘t Create");//防止通过其他途径去实例化对象 4 } 5 public static final LazyInnerClassSingleton getInstance(){ 6 return LazyHolder.LAZY; 7 } 8 private static class LazyHolder{ 9 private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton(); 10 } 11 }
特点：只有在调用getInstance的方法的同时，才会去初始化，并且只有一个线程可以活得对象的初始化锁。保证线程安全。【最优写法】
【对象初始化锁】还有待查询学习。
4. 枚举实现单例模式
1 public enum EnumSingleton { 2 INSTANCE; 3 4 public static EnumSingleton getInstance(){ 5 return INSTANCE; 6 } 7 }
特点：利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。
【但是】
使用序列化，反序列化仍然可以将单例模式破坏
1 public class SingletonTest { 2 public static void main(String[] args) throws Exception{ 3 LazySingleton s1 = null; 4 LazySingleton s = LazySingleton.getInstance(); 5 FileOutputStream fos = new FileOutputStream("a.txt"); 6 ObjectOutputStream oos = new ObjectOutputStream(fos); 7 oos.writeObject(s); 8 oos.flush(); 9 oos.close(); 10 FileInputStream fis = new FileInputStream("a.txt"); 11 ObjectInputStream ois = new ObjectInputStream(fis); 12 s1 = (LazySingleton) ois.readObject(); 13 } 14 }
通过程序，s1与s的地址信息不同，证明为非单例对象
解决办法：
1 private Object readResolve(){ 2 System.out.println("read resolve"); 3 return instance; 4 }
加上此方法后，jdk中ObjectInputStream的类中有readUnshared（）方法。
如果有该方法， 则会执行浅拷贝。【原因：去翻源码，还没看】
深拷贝和浅拷贝的区别，简述：
在JVM中，对象都保存在堆中，对象的引用都保存在栈中。
浅拷贝：只是赋值一个对象的引用，并指向在堆中的原对象。
深拷贝：栈中的引用和堆中的内存都赋值一份，并且新引用指向新内存。
所以，浅拷贝完全符合单例。
深拷贝，浅拷贝，以及加上readResolve方法后，为什么执行浅拷贝，以后补一下
标签：resolve private 允许 style 初始化 vat 深拷贝 volatil 地址空间
原文地址：https://www.cnblogs.com/theMonster/p/12883603.html
