设计模式单例模式的7种实现

//不允许被继承
public final class SingletonHungry {private static SingletonHungry instance &＃61; new SingletonHungry();private SingletonHungry() {}public static SingletonHungry getInstance() {return instance;}
}

饿汉式的关键在于如果使用这个单例类&＃xff0c;那么instance会直接被创建&＃xff0c;包括其中的实例对象。总的来说&＃xff0c;其线程安全行建立在JVM对类的加载是保证线程安全的。即保证类只会被加载一次。
这样的有一个缺陷就是如果instance被实例化的同时&＃xff0c;类中同时存在很多其他资源也同时被实例化了&＃xff0c;那么就会占用很多系统资源。所以这个时候就需要懒汉式。

public final class SingletonLazy {private static SingletonLazy instance;private SingletonLazy(){}public static SingletonLazy getInstance(){if (null&＃61;&＃61;instance) instance &＃61; new SingletonLazy();return instance;}
}


虽然说会判断一次instance是否会被实例化&＃xff0c;但在多线程下不会保证instance的唯一性。
如下例子就可以证明:
线程a正在创建的过程中&＃xff0c;此时线程b进来了判断null&＃61;&＃61;instance是成立的&＃xff0c;因为线程a并没有创建好&＃xff0c;那么线程b也会再来创建一次。而线程b创建过程中&＃xff0c;线程a的instance引用可能已经被其他方法捕获&＃xff0c;那么系统堆内存里就可能同时存在两个instance实例。

public final class SingletonLazySync {private static SingletonLazySync instance;private SingletonLazySync(){}public static synchronized SingletonLazySync getInstance(){if (null&＃61;&＃61;instance) instance &＃61; new SingletonLazySync();return instance;}
}


介于synchronized的性能&＃xff0c;可能这个getInstance方法在系统内是十分频繁的&＃xff0c;那么每次获取都需要进行一次加锁解锁&＃xff0c;性能十分的底下。

public final class SingletonDoubleCheck {private static SingletonDoubleCheck instance;private SingletonDoubleCheck() {}public static synchronized SingletonDoubleCheck getInstance() {if (null &＃61;&＃61; instance) {synchronized (SingletonDoubleCheck.class) {if (null &＃61;&＃61; instance)instance &＃61; new SingletonDoubleCheck();}}return instance;}
}


当两个线程发现null&＃61;instance时&＃xff0c;只有一个线程能够进入同步块&＃xff0c;完成对instance的实例化&＃xff0c;等一个线程完成创建后其他线程才会有机会进入同步块进行创建&＃xff0c;而此时instance已经被创建好了。等下一次获取的时候&＃xff0c;就不需要进入同步块了。这样在性能上就十分的优秀&＃xff0c;基本上就是只给创建过程加一个同步操作。只需要保证只创建一次就够了。

但是这种情况下仍然存在空指针的情况&＃xff0c;其原因是多线程下的指令重排序造成的。

如下例子可以解释&＃xff1a;
线程a 进入创建instance过程&＃xff0c;可能这个创建有点耗时&＃xff08;可能存在其他成员需要初始化&＃xff09;&＃xff0c;并且instance其他成员变量还没有初始化好&＃xff0c;这个时候线程b进入getInstance&＃xff0c;发现instance不为空&＃xff0c;那么就可以直接跳过这个过程&＃xff0c;而获取到instance的引用&＃xff0c;这时候b线程又需要应用引用到其他成员&＃xff0c;而其他成员a线程并没有初始化好&＃xff0c;那么就会出现空指针的异常。
这个instance已经实例化好&＃xff0c;而instance其他成员变量还没有实例化好的情况&＃xff0c;存在于并没有显式的happens-before关系进行约束&＃xff0c;且JVM存在指令重排序的情况。

public final class SingletonSingletonDoubleCheck {private volatile static SingletonSingletonDoubleCheck instance;private SingletonSingletonDoubleCheck() {}public static synchronized SingletonSingletonDoubleCheck getInstance() {if (null &＃61;&＃61; instance) {synchronized (SingletonSingletonDoubleCheck.class) {if (null &＃61;&＃61; instance)instance &＃61; new SingletonSingletonDoubleCheck();}}return instance;}
}


这种方法是借助于Volatile的强行禁止指令重排序来实现的。

public final class SingletonHolder {private SingletonHolder() {}private static class Holder{private static SingletonHolder instance&＃61; new SingletonHolder();}public static SingletonHolder getInstance() {return Holder.instance;}
}


在SingletonHolder类的初始化过程中并不会创建SingletonHolder的实例&＃xff0c;只有在Holder被主动引用的时候&＃xff0c;则instance会被创建。instance实例的创建过程在JAVA程序编译时期收集至<\clinit>()方法中&＃xff0c;该方法是同步方法&＃xff0c;而同步方法可以保证内存的可见性&＃xff0c;JVM指令的顺序性和原子性。该单例方法是十分优秀的设计。

public enum SingletonEnum {INSTANCE;SingletonEnum() {System.out.println("INSTANCE 马上会被实例化");}public static SingletonEnum getInstance() {return INSTANCE;}
}


枚举类型不允许被继承&＃xff0c;同样是线程安全的且只能被实例化一次。

为了使一个单例类变成可串行化的&＃xff0c;仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候&＃xff0c;都会创建一个新的对象&＃xff0c;而不仅仅是一个对原有对象的引用。为了防止这种情况&＃xff0c;可以在单例类中加入readResolve 方法。

　//在序列化完成后readResolve返回的对象将替代readObject的private Object readResolve() {return singleton;}