java性能优化--代理--单例
单例模式是一种对象创建模式，用于生产对象的一个具体实例，它可以确保系统中一个类只产生一个实例。该模式能带来两大好处：
1. 对于频繁使用的对象，可以省略创建对象所花费的时间。
2. 由于new的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力、缩短gc停顿时间
单例模式的核心，在于通过一个接口返回唯一的对象实例。一个简单的单例实现：
public class Singleton {
private Singleton(){
System.out.println("create a Singleton");
}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){ return instance;
}
} 首先，单例必须有一个private访问级别的构造函数，只有这样，才能确保单例不会在系统中的其他代码内被实例化；其次，instance成员变量和getInstance()的方法必须是static的
这种实现方式很简单并且还是十分可靠的，它唯一的不足就是无法对instance进行延迟加载，实现延迟的代码为
public class LazySingleton {
private LazySingleton(){
System.out.println("LazySingleton is create");
}
private static LazySingleton instance = null;
public static synchronized LazySingleton getInstance(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
首先，对于静态变量instance初始值赋予null，确保系统启动时没有额外的负载；
其次，get方法必须是同步的，否则在多线程请扩下，可能会多次创建！
但是由于引入了同步，其性能会和第一种情况差了很多，所以这种降低了系统性能的做法，是有点不可取的，所以我们对其进行改进：
public class StaticSingleton {
private StaticSingleton(){
System.out.println("create a StaticSingleton");
}
private static class SingletonHolder{
private static StaticSingleton instance = new StaticSingleton();
}
public static StaticSingleton getInstance(){
return SingletonHolder.instance;
}
}
这个实现中，单例模式使用内部类来维护实例，当StaticSingleton被加载时，其内部类不会初始化，故可以在调用getInstance()方法调用，才会加载SingletonHolder.同时，由于实例的建立实在类加载时完成，故天生对多线程友好
通常情况下上面的代码可以确保系统中唯一实例。但是仍有意外情况，比如利用反射，这种情况我们不讨论，我们讨论一种合理的方法：
public class SerSingleton implements Serializable {
String name;
private SerSingleton(){
System.out.println("create a SerSingleton");
name = "SerSingleton";
}
private static SerSingleton instance = new SerSingleton();
public static SerSingleton getInstance(){
return instance;
}
public static void createString(){
System.out.println("createString in Singleton");
}
// private Object readResolve(){
// return instance;
// }
}
// TODO Auto-generated method stub
SerSingleton s1 = null;
SerSingleton s = SerSingleton.getInstance();
//先将实例串行化到文件
FileOutputStream fos = new FileOutputStream("s.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.flush();
oos.close();
//从文件读出
FileInputStream fis = new FileInputStream("s.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
s1= (SerSingleton) ois.readObject();
// Assert.assertEquals(s,s1);
System.out.println(s.equals(s1));
如果在第一段代码中去掉readResovle(),那么测试代码（经过串行化和反串行化）后，s和s1指向了不同的实例；加上之后便解决该问题。
即使构造函数是私有的，可序列化工具依然可以通过特殊的途径去创建类的一个新的实例。序列化操作提供了一个很特别的钩子（hook）-类中具有一个私有的被实例化的方法readresolve(),这个方法可以确保类的开发人员在序列化将会返回怎样的object上具有发言权。足够奇怪的，readresolve()并不是静态的，但是在序列化创建实例的时候被引用。