设计模式-单例模式

问题：应用系统同有时必须保证系统中某个类有且只有一个实例，并且提供全局访问点。

解决方案：构造函数私有，提供全局可访问的方法返回实例。

实现方式1：最简单的单例实现方式。

优点：实现简单，线程安全。

缺点：没有延迟加载，对性能可能会造成影响，只要加载类或者调用同一类的其他方法就会产生实例(实际没有使用此实例)。

示例代码：

public class Singleton{

private static Singleton instance = new Singleton();

private Singleton(){}

public Singleton getInstance(){

return instance;

}

}

实现方式2：将创建对象移到全局访问方法内部，并判断成员是否为空，不为空返回对象，反之创建对象并返回。为了保证在多线程环境中不会产生多个对象，需对全局访问方法加同步锁。

优点：实现了延迟加载，线程安全。

缺点：多线程环境下会造成性能明显下降。

示例代码:

public class LazySingleton{

private static LazySingleton instance=null;

private LazySingleton(){}

public static synchronized LazySingleton getInstance(){

if(instance==null)

instance = new LazySingleton();

return instance;

}

}

实现方式3：double-check Locking,全局访问方法内部进行双重校验属性是否为空，并于一重和二重校验之间添加同步锁（保证类实例化过程，只进行一次，即保证永远只会产生一个实例），成员属性需要用volatile关键字修饰。

优点：实现实际使用实例时才加载，双重校验保证只产生一个实例的同时也保证了多线程环境下访问的性能，线程安全。

缺点：

示例代码：

public class DoubleCheckSingleton{

private volatile static DoubleCheckSingleton instance=null;

private DoubleCheckSingleton(){}

public static DoubleCheckSingleton getInstance(){

if(instance==null)

synchronized(DoubleCheckSingleton.class){

if(instance==null) instance= new DoubleCheckSingleton();

}

return instance;

}

}

实现方式4:通过内部类的方式实现，不加载内部类不会产生实例。

优点：线程安全，没有static属性，不调用全局访问方法不会产生实例。

缺点：

示例代码：

pulbic class InnerClassSingleton{

private InnerClassSingleton(){}

private static class LazyHolder{

private static final InnerClassSingleton singletonInstance = new InnerClassSingleton();

}

public static InnerClassSingleton getInstance(){

return LazyHolder.singletonInstance;

}

}

单例模式序列化:如果单例模式实现了serializable接口，默认情况下，反序列化会产生一个新的对象，此时并不能保证系统中单例类只产生一个对象，为了保证对象唯一，我们需要重写readResolve()。

代码示例:

public class Singleton implements Serializable{

private static Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return instance;

}

private Object readResolve(){

return instance;

}

}