懒汉式单例
被外部类调用时才创建实例
//懒汉式单例 //在外部需要使用的时候才进行实例化 public class LazySimpleSingleton {private LazySimpleSingleton(){}//静态块，公共内存区域private static LazySimpleSingleton lazy = null;public synchronized static LazySimpleSingleton getInstance(){if(lazy == null){lazy = new LazySimpleSingleton();}return lazy;} } public class ExectorThread implements Runnable{@Overridepublic void run() {LazySimpleSingleton singleton = LazySimpleSingleton.getInstance(); // ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();System.out.println(Thread.currentThread().getName() + ":" + singleton);} } public class LazySimpleSingletonTest {public static void main(String[] args) {Thread t1 = new Thread(new ExectorThread());Thread t2 = new Thread(new ExectorThread());t1.start();t2.start();System.out.println("End");} } public class LazyDoubleCheckSingleton {private volatile static LazyDoubleCheckSingleton lazy = null;private LazyDoubleCheckSingleton(){}public static LazyDoubleCheckSingleton getInstance(){if(lazy == null){synchronized (LazyDoubleCheckSingleton.class){if(lazy == null){lazy = new LazyDoubleCheckSingleton();//1.分配内存给这个对象//2.初始化对象//3.设置lazy指向刚分配的内存地址//4.初次访问对象}}}return lazy;} } //这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题 //完美地屏蔽了这两个缺点 //史上最牛B的单例模式的实现方式 public class LazyInnerClassSingleton {//默认使用LazyInnerClassGeneral的时候，会先初始化内部类//如果没使用的话，内部类是不加载的private LazyInnerClassSingleton(){if(LazyHolder.LAZY != null){throw new RuntimeException("不允许创建多个实例");}}//每一个关键字都不是多余的//static 是为了使单例的空间共享//保证这个方法不会被重写，重载public static final LazyInnerClassSingleton getInstance(){//在返回结果以前，一定会先加载内部类return LazyHolder.LAZY;}//默认不加载private static class LazyHolder{private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();} } public class LazyInnerClassSingletonTest {public static void main(String[] args) {try{//很无聊的情况下，进行破坏Class<?> clazz = LazyInnerClassSingleton.class;//通过反射拿到私有的构造方法Constructor c = clazz.getDeclaredConstructor(null);//强制访问，强吻，不愿意也要吻c.setAccessible(true);//暴力初始化Object o1 = c.newInstance();//调用了两次构造方法，相当于new了两次//犯了原则性问题，Object o2 = c.newInstance();System.out.println(o1 == o2); // Object o2 = c.newInstance();}catch (Exception e){e.printStackTrace();}} } public class SeriableSingletonTest {public static void main(String[] args) {SeriableSingleton s1 = null;SeriableSingleton s2 = SeriableSingleton.getInstance();FileOutputStream fos = null;try {fos = new FileOutputStream("SeriableSingleton.obj");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(s2);oos.flush();oos.close();FileInputStream fis = new FileInputStream("SeriableSingleton.obj");ObjectInputStream ois = new ObjectInputStream(fis);s1 = (SeriableSingleton)ois.readObject();ois.close();System.out.println(s1);System.out.println(s2);System.out.println(s1 == s2);} catch (Exception e) {e.printStackTrace();}} } //反序列化时导致单例破坏 public class SeriableSingleton implements Serializable {//序列化就是说把内存中的状态通过转换成字节码的形式//从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)//内存中状态给永久保存下来了//反序列化//讲已经持久化的字节码内容，转换为IO流//通过IO流的读取，进而将读取的内容转换为Java对象//在转换过程中会重新创建对象newpublic final static SeriableSingleton INSTANCE = new SeriableSingleton();private SeriableSingleton(){}public static SeriableSingleton getInstance(){return INSTANCE;}private Object readResolve(){return INSTANCE;}} public final Object readObject()throws IOException, ClassNotFoundException {if (enableOverride) {return readObjectOverride();}// if nested read, passHandle contains handle of enclosing objectint outerHandle = passHandle;try {Object obj = readObject0(false);handles.markDependency(outerHandle, passHandle);ClassNotFoundException ex = handles.lookupException(passHandle);if (ex != null) {throw ex;}if (depth == 0) {vlist.doCallbacks();}return obj;} finally {passHandle = outerHandle;if (closed && depth == 0) {clear();}} } private Object readObject0(boolean unshared) throws IOException {boolean oldMode = bin.getBlockDataMode();if (oldMode) {int remain = bin.currentBlockRemaining();if (remain > 0) {throw new OptionalDataException(remain);} else if (defaultDataEnd) {/** Fix for 4360508: stream is currently at the end of a field* value block written via default serialization; since there* is no terminating TC_ENDBLOCKDATA tag, simulate* end-of-custom-data behavior explicitly.*/throw new OptionalDataException(true);}bin.setBlockDataMode(false);}byte tc;while ((tc = bin.peekByte()) == TC_RESET) {bin.readByte();handleReset();}depth++;totalObjectRefs++;try {switch (tc) {case TC_NULL:return readNull();case TC_REFERENCE:return readHandle(unshared);case TC_CLASS:return readClass(unshared);case TC_CLASSDESC:case TC_PROXYCLASSDESC:return readClassDesc(unshared);case TC_STRING:case TC_LONGSTRING:return checkResolve(readString(unshared));case TC_ARRAY:return checkResolve(readArray(unshared));case TC_ENUM:return checkResolve(readEnum(unshared));case TC_OBJECT:return checkResolve(readOrdinaryObject(unshared));case TC_EXCEPTION:IOException ex = readFatalException();throw new WriteAbortedException("writing aborted", ex);case TC_BLOCKDATA:case TC_BLOCKDATALONG:if (oldMode) {bin.setBlockDataMode(true);bin.peek(); // force header readthrow new OptionalDataException(bin.currentBlockRemaining());} else {throw new StreamCorruptedException("unexpected block data");}case TC_ENDBLOCKDATA:if (oldMode) {throw new OptionalDataException(true);} else {throw new StreamCorruptedException("unexpected end of block data");}default:throw new StreamCorruptedException(String.format("invalid type code: %02X", tc));}} finally {depth--;bin.setBlockDataMode(oldMode);}} private Object readOrdinaryObject(boolean unshared)throws IOException{if (bin.readByte() != TC_OBJECT) {throw new InternalError();}ObjectStreamClass desc = readClassDesc(false);desc.checkDeserialize();Class<?> cl = desc.forClass();if (cl == String.class || cl == Class.class|| cl == ObjectStreamClass.class) {throw new InvalidClassException("invalid class descriptor");}Object obj;try {obj = desc.isInstantiable() ? desc.newInstance() : null;} catch (Exception ex) {throw (IOException) new InvalidClassException(desc.forClass().getName(),"unable to create instance").initCause(ex);}passHandle = handles.assign(unshared ? unsharedMarker : obj);ClassNotFoundException resolveEx = desc.getResolveException();if (resolveEx != null) {handles.markException(passHandle, resolveEx);}if (desc.isExternalizable()) {readExternalData((Externalizable) obj, desc);} else {readSerialData(obj, desc);}handles.finish(passHandle);if (obj != null &&handles.lookupException(passHandle) == null &&desc.hasReadResolveMethod()){Object rep = desc.invokeReadResolve(obj);if (unshared && rep.getClass().isArray()) {rep = cloneArray(rep);}if (rep != obj) {// Filter the replacement objectif (rep != null) {if (rep.getClass().isArray()) {filterCheck(rep.getClass(), Array.getLength(rep));} else {filterCheck(rep.getClass(), -1);}}handles.setObject(passHandle, obj = rep);}}return obj;} obj = desc.isInstantiable() ? desc.newInstance() : null; boolean isInstantiable() {requireInitialized();return (cons != null); } if (obj != null &&handles.lookupException(passHandle) == null &&desc.hasReadResolveMethod()) {Object rep = desc.invokeReadResolve(obj);if (unshared && rep.getClass().isArray()) {rep = cloneArray(rep);}if (rep != obj) {// Filter the replacement objectif (rep != null) {if (rep.getClass().isArray()) {filterCheck(rep.getClass(), Array.getLength(rep));} else {filterCheck(rep.getClass(), -1);}}handles.setObject(passHandle, obj = rep);} } readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);超强干货来袭 云风专访：近40年码龄，通宵达旦的技术人生
总结
