单例模式
概念：
在应用程序中保证有且只有一个实例。
1.懒汉式
public class Single implements Serializable {private static final long serialVersionUID = 1L;private static Single single;private static volatile boolean flag = false;private Single() {/** 防止反射多线程调用 */synchronized(Single.class) {/*** 防止反射破坏单例模式* 若flag为true，表示已经通过构造器创建过实例，则抛出异常，为false则正常创建实例。*/if (flag) {throw new RuntimeException("不可重复创建Single实例");}flag = true;}}public static Single getInstance(){if (this.single == null) {// 使用同步锁，防止多线程下创建多个对象synchronized (Single.class) {// 双重校验if (this.single == null){single = new Single();}}}return single;}/*** 防止反序列化破坏单例模式（为什么要创建readResolve方法，具体看源码）（如果类未实现Serializable接口，该方法可以忽略）*/public Object readResolve() {return single;}
}总结：
1.懒汉式是在第一次使用实例的时候去创建实例，创建完后会一直存在，直到系统停止；
2.显性创建实例，多线程下线程不安全（多线程下使用synchronized和双重锁来解决线程安全）。
2.饿汉式（静态变量）
public class Single implements Serializable {private static final long serialVersionUID = 1L;/** 在加载Single类的时候创建instance变量（系统启动时会加载类） */private static final Single INSTANCE = new Single();private static volatile boolean flag = false;/** 私有化构造器 */private Single(){/** 防止反射多线程调用 */synchronized(Single.class) {/*** 防止反射破坏单例模式* 若flag为true，表示已经通过构造器创建过实例，则抛出异常，为false则正常创建实例。*/if (flag) {throw new RuntimeException("不可重复创建Single实例");}flag = true;}}/** 对外提供获取实例的方法 */public static Single getInstance(){return INSTANCE;}/*** 防止反序列化破坏单例模式*/public Object readResolve() {return INSTANCE;}
}3.饿汉式（静态代码块）
public class Single implements Serializable {private static final long serialVersionUID = 1L;private static final Single INSTANCE;private static volatile boolean flag = false;static {INSTANCE = new Single();}private Single() {/** 防止反射多线程调用 */synchronized(Single.class) {/*** 防止反射破坏单例模式* 若flag为true，表示已经通过构造器创建过实例，则抛出异常，为false则正常创建实例。*/if (flag) {throw new RuntimeException("不可重复创建Single实例");}flag = true;} }/** 对外提供获取实例的方法 */public static Single getInstance(){return INSTANCE;}/*** 防止反序列化破坏单例模式（为什么要创建readResolve方法，具体看源码）（如果类未实现Serializable接口，该方法可以忽略）*/public Object readResolve() {return INSTANCE;}
}4.饿汉式（枚举）（枚举本身是线程安全的）
public enum Single {INSTANCE;
}总结：
1.饿汉式是在类加载初始化时创建唯一实例，该实例在整个系统运行中会一直存在，不会被垃圾回收，直到系统停止；
2.隐性创建实例，使用方便，但存在内存浪费的问题（生命周期与系统的生命周期一致）；
3.线程安全。
破坏单例模式的方式（以枚举创建的单例模式除外）
1.反序列化（若单例模式未实现Serializable接口可忽略 ，只有实现了Serializable接口才会出现反序列化破坏单例模式的情况）
public class test {public static void main (String[] args) {writeObjectToFile();readObjectFromFile()}// 向文件中读数据public static void readObjectFromFile() throws Exception {ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\a.txt"));Single s1 = (Single) ois.readObjecct();Single s2 = (Single) ois.readObjecct();System.out.println(s1 == s2);ois.close();}// 向文件中写数据public static void writeObjectToFile() throws Exception {Single single = Single.getInstance();ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\a.txt"));oos.writeObject(single);oos.close();}
}通过反序列化的方式创建了多个不同的实例，破坏了单例模式。解决方案是新增readResolve()方法。新增的readResolve()方法已经存在上面的单例模式中。
2.反射
public class test {public static void main (String[] args) {// 1.获取字节码对象Class clazz = Single.class;// 2.获取对象的无参构造器Constructor cons = clazz.getDeclaredConstructor(); // 3.因为无参构造器是私有的，所以取消权限访问的检查cons.setAccessible(true);// 4.创建对象Single s1 = (Single) cons.newInstance();Single s2 = (Single) cons.newInstance();System.out.println(s1 == s2);// false}
}Java的反射机制可创建多个实例从而破坏单例模式，解决方案即是使用双重非空判断，加synchronized关键字是应对多线程的情况，所以synchronized+双重非空判断可防止反射破坏单例模式。代码的写法已经在上面的例子中写出来了。
扩展：
JDK中 - Runtime类使用的是单例模式（饿汉式）
public class test{public static void main(String[] args){Runtime runtime = Runtime.getRuntime();// 参数是一个命令Process process = runtime.exec("ipconfig");InputStream is = process.getInputStream();byte[] arr = new byte[1024 * 1024 * 100];// 读取到数据的字节长度int len = is.read(arr);// 输入到控制台System.out.println(new String(arr, 0, len, "GBK"));}
}
