善用设计模式（一）单例模式

单例模式是设计模式中使用最普遍的一种模式之一。它是一种对象创建模式，用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。
使用单例模式有俩大好处：

对于频繁使用的对象，可以省去对象创建所花费的时间，这对也那些重量级对象是很可观的。
由于new操作的减少，对系统内存的使用频率降低，这会减轻GC的压力，缩短GC的停顿时间。

单例模式的核心在于通过一个接口返回唯一的对象实例。
单例模式有懒汉式和恶汉式。
饿汉式是在不管你用不用，一开始就创建单例对象，这里的一开始，指的是该类加载的时候，例如下面的代码：

public class Singleton{
    private static NeededObiect instance = new NeededObiect(); 
    private Singleton(){
    }
    public static NeededObiect getInstance() {  
        return instance;
    }
}

“懒汉式”是在你真正用到的时候才去实例化单例对象，例如下面的代码：

public class LazySingleton{
    private static NeededObiect instance = null; 
    private LazySingleton(){
    }
    // 加锁，同步执行单例模式，防止多线程同时创建单例对象  
    public static synchronized NeededObiect getInstance() {
        if(instance == null){
            instance = new NeededObject();
        } 
        return instance;
}

为了使用延迟加载引入的同步关键字反而降低了系统的性能，为了解决这个问题还可以对其进行改进,使用内部类来维护单例的实例，当StaticSingleton被加载时其内部类并不会初始化，保证StaticSingletion类被载入JVM时不会初始化单例类，而当getInstance（）方法被调用时才会加载SingletonHolder从而初始化instance。

public class StaticSingleton{
    private StaticSingleton(){
    }
    private static class SingletonHolder(){
        private static NeededObject instance = new NeededObject();
    }
    private static NeededObject getInstance(){
        return SingletonHolder.instace;
    }
}

使用内部类的方式实现单例，既可以做到延迟加载，也不必使用同步关键字，是一种比较完善的实现。

通常情况下，用以上方式可以保证在系统中只存在唯一实例。但当代码中使用反射机制强行调用方法单例类中的私有构造函数，生成多个单例。

解决序列化与反序列化中的单例模式问题

public class SerSingleton implements java.io.Serializable{
    String name;
    private Seringleton(){
        name = "SerSingleton";
    }
    private static NeededObject instance = new NeededObject();
    public static SerSingleton getInstance(){
        return instance;
    }
    private Object readResolve(){//阻止形成新的实例，总是返回当前对象。
        return instance;
    }
}