单例模式
单例模式,是一种常用的软件设计模式。单例模式用于保证系统中,某一个类只有一个实例。即一个类只有一个对象实例。例如,Hibernate的SessionFactory类,该类是一个重量级的类,里面包含了数据库的所有信息,对于一个数据库应该只有一个SessionFactory实例。
单例模式的实现方式有很多,主要分为懒汉模式和饿汉模式。
一 单例模式实现
懒汉模式
public class LazySingleton {
private static LazySingleton lazySingleton = null;
private LazySingleton() {
}
public static LazySingleton getLazySingleton() {
if (lazySingleton == null) {
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
单例模式就是把构造方法给私有化,使外部无法直接创建对象,而需要我们提供的公开方法来获取,在我们的获取对象方法中,先判断对象是否为空,为空则才会创建一个新对象返回,那么就保证了外部使用的始终是同一个对象。
缺点:线程不安全。
这种写法在极端情况下是非线程安全的,例如,当一个线程判断对象为空,那么开始执行new操作来创建对象,我们知道,在new对象的时候是非常消耗性能的,她并不是一个原子性的操作,那么在并发情况下,另一个线程同时进入方法,在判断对象是否为空的时候,因为上一个线程的new对象还没有完成,此时返回为true,也进入代码块进行对象创建,那么得到的就不是同一个对象了。如果要实现线程安全,我们可以为其加上同步锁来保证线程的同步。
public synchronized static LazySingleton getLazySingleton(){
if(lazySingleton==null){
lazySingleton=new LazySingleton();
}
return lazySingleton;
}
}
加上同步锁能够很好的解决线程安全的问题,可这里又有新的问题了,我们知道对锁的操作是十分消耗性能的,这里每次调用方法都要先获取锁,十分影响效率,因此,我们可以使用双重验证锁的方式来实现单例模式。
public static LazySingleton getLazySingleton(){
if(lazySingleton==null){
synchronized (LazySingleton.class) {
if(lazySingleton==null) {
lazySingleton = new LazySingleton();
}
}
}
return lazySingleton;
}
这里只有第一次创建对象的时候才会获取对象锁,这样即保证了线程安全,又不影响效率,目前这是最完美的懒汉模式实现方式。
饿汉模式
public class EagerSingleton{
private static final EagerSingleton EAGER_SINGLETON = new EagerSingleton();
private EagerSingleton() {
}
public static EagerSingleton getEagerSingleton() {
return EAGER_SINGLETON;
}
}
饿汉模式在类加载的时候就初始化了对象,其保证了线程安全性,因为其在类加载的时候就被初始化了,很有可能造成内存垃圾,假如这个实列一直没被调用,那么这个对象是不应该被创建的,对于这种情况我们可以使用懒汉模式。一般情况下,在工作中,饿汉模式用的比较多,其实现简单,只有在类加载的时候稍慢一点,返回对象特别快。
再来看一种内部类实现的懒汉模式,又名登记式
public class InnerClassSingleton{
private InnerClassSingleton() {
}
public static InnerClassSingleton getInnerClassSingleton() {
return InnerClassSingletonHolder.INNER_CLASS_SINGLETON;
}
private static class InnerClassSingletonHolder {
private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
}
}
这种方式是利用JVM的类加载机制保证了线程安全来实现单例模式,在使用InnerClassSingleton其它方法的时候都不会创建该实例,只有调用getInnerClassSingleton()方法的时候,开始调用静态内部类,此时静态内部类才开始加载,初始化实例。
还有一种特殊的饿汉模式实现,通过枚举类来实现单例模式
public enum EnumSingleton {
INSTANCE;
public void execute(){
System.out.println("执行方法");
}
}
枚举类不用多说,和静态类类似,当类加载的时候进行初始化,值得注意的是,枚举类是在jdk1.5才出现的,所以用的传统的饿汉模式的人比较多。
二 在特殊需求下,单例模式的问题
有些时候我们需要把对象进行序列化与反序列化,下面我们就来测试反序列化后的对象与原对象是否是同一个对象。
public class EagerTest {
public static void main(String[] args) throws Exception{
EagerSingleton singleton=EagerSingleton.getEagerSingleton();
FileOutputStream outputStream=new FileOutputStream("eager");
ObjectOutputStream oup=new ObjectOutputStream(outputStream);
oup.writeObject(singleton);
oup.close();
outputStream.close();
FileInputStream inputStream=new FileInputStream("eager");
ObjectInputStream ois=new ObjectInputStream(inputStream);
EagerSingleton eagerSingleton=(EagerSingleton) ois.readObject();
ois.close();
inputStream.close();
System.out.println(singleton==eagerSingleton);
}
}
运行结果:
首先不要忘记类要实现Serializable接口,这里以饿汉模式为例进行测试,可以看到反序列化后两个对象比较为false,说明这种方式创建的单例在反序列化后会出现问题,不能保证实例的唯一性了。解决这个问题只需要在类中加入下面的方法
public class EagerSingleton implements Serializable{
private static final EagerSingleton EAGER_SINGLETON = new EagerSingleton();
private static final long serialVersionUID = -6655710258921072343L;
private EagerSingleton() {
}
public static EagerSingleton getEagerSingleton() {
return EAGER_SINGLETON;
}
private Object readResolve() throws ObjectStreamException {
return getEagerSingleton();
}
}
这里新加入了readResolve()方法,该方法在反序列化的时候会被自动调用,我们再次运行测试代码,看运行结果
再来对枚举类实现的单例模式进行反序列化测试
public class Test {
public static void main(String[] args) throws Exception{
EnumSingleton singleton=EnumSingleton.INSTANCE;
FileOutputStream outputStream=new FileOutputStream("enum");
ObjectOutputStream oup=new ObjectOutputStream(outputStream);
oup.writeObject(singleton);
oup.close();
outputStream.close();
FileInputStream inputStream=new FileInputStream("enum");
ObjectInputStream ois=new ObjectInputStream(inputStream);
EnumSingleton enumSingleton=(EnumSingleton) ois.readObject();
ois.close();
inputStream.close();
System.out.println(singleton==enumSingleton);
}
}
运行结果:
总结:使用枚举类实现的单例模式在反序列化情况下不会发生问题,反序列化生成的对象与原对象一致,其它方式实现的单例模式在反序列化中会出现问题,反序列化生成的对象与原对象不一致,会使单例模式的实例产生多个的问题,解决方法,在类中加上readResove()方法。