为什么使用单例模式？
确保某一个类只有一个实例，避免产生多个对象消耗过多的资源， 如要访问IO和 数据库等资源
实现单例模式的几个关键点：
构造函数不对外开放，一般为private
通过一个静态方法或枚举返回单例类对象
确保单例类的对象只有一个，尤其是在多线程环境下
确保单例类对象反序列化时不会重新构建对象
饿汉模式—空间换取时间，线程安全
public class Singleton {
private Singleton() { }
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
懒汉模式
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
在getinstance方法中加入了synchronized关键字，也就是getInstance是一个同步方法，是线程安全的，但是这种方式存在性能上的缺陷，每次调用getInstance都会进行同步，消耗不必要的资源
优点：只有在使用时才会被实例化，在一定程度上节约了资源
缺点：第一次加载时需要及时实例化，反应稍慢，最大问题是每次调用getInstance都进行同步，造成不必要的同步开销
Double check lock 模式
能够在需要时才实例化，保证线程安全，只有在第一次调用时才进行同步，以后调用getInstance都不会进行同步锁
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
getInstance方法中对instance进行了两次判空，第一次主要是为了避免不必要的同步，第二层则是为了在null的情况下创建实例
instance = new Singleton();此操作并不是一个原子操作，这句代码最终会被编译成多条汇编指令
- 给Singleton的实例分配内存
- 调用Singleton的构造函数，初始化成员字段
- 将instance对象指向分配的内存空间（此时instance就不是null了）
由于Java编译器允许处理器乱序执行，第2，3条的指令执行顺序是无法保证的，执行顺序可能为1-2-3或1-3-2，假定A线程执行的顺序为1-3-2，当执行到第三条指令时，此时instance已经不为null，切换到B线程，判断instance不为空，直接取走了instance，使用时就会报错，double check lock模式此时就失效了。
在Java1.5以后，具体化了volatile关键字，volatile会将修改的变量值立即更新到主存中，保证变量的可见性，只需将instance定义改为private volatile static Singleton instance = null，就可以保证instance对象每次都是从主内存中读取。
优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化
缺点：第一次加载时反应稍慢
静态内部类模式
public class Singleton {
private Singleton() {}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
}
第一次加载Singleton类时并不会初始化instance，只有在第一次调用getInstance方法时才会初始化instance实例，因此，第一次调用getInstance方法会触发虚拟机加载SingletonHolder类，这种方式不仅能保证线程安全，也能保证实例对象的唯一性，同时也延迟了单例的实例化，推荐用此模式
枚举单例
public enum Singleton {
INSTANCE;
public void doSomething() {
}
}
枚举在Java中和普通类是一样的，不仅能够拥有字段，还能有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。
在上述几种单例模式的实现中，在反序列化的情况下他们会出现重新穿件对象，枚举方式则不会
通过序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而有效的获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新实例。反序列化操作提供了一个很特别的钩子函数readResolve，如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入readResolve函数，也就是在readResolve函数中将单例对象返回，而不是重新生成一个新对象。
private Object readResolve() {
return SingletonHolder.instance;
}
public class Singleton implements Serializable {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
// private Object readResolve() {
// return SingletonHolder.instance;
// }
public static void main(String[] args) throws IOException, ClassNotFoundException {
Singleton s = Singleton.getInstance();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.obj"));
oos.writeObject(s);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("Singleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Singleton s1 = (Singleton) ois.readObject();
ois.close();
System.out.println(s + "\n" + s1);
}
}
//output
com.miracle.thirdlibsourcecode.Singleton@1d44bcfa
com.miracle.thirdlibsourcecode.Singleton@6acbcfc0
不加钩子函数反序列化的时候则会创建新的对象
public class Singleton implements Serializable {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
private Object readResolve() {
return SingletonHolder.instance;
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Singleton s = Singleton.getInstance();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.obj"));
oos.writeObject(s);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("Singleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Singleton s1 = (Singleton) ois.readObject();
ois.close();
System.out.println(s + "\n" + s1);
}
}
//output
com.miracle.thirdlibsourcecode.Singleton@1d44bcfa
com.miracle.thirdlibsourcecode.Singleton@1d44bcfa
加了钩子函数readResolve以后，反序列化就不会重新创建对象了
而对于枚举，并不存在这个问题，因为即使反序列化也不会生成新的实例对象
通过对enum反编译发现其实enum是继承了Enum抽象类，在反序列化时，反射在通过newInstance创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败。
