单例模式
概念：
在应用程序中保证有且只有一个实例。
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"));
}
}
