饿汉式
|
/** * 饿汉式：开始就创建了对象，饥不择食 */ class SingletonHungry {
private static SingletonHungry singletonHungry = new SingletonHungry();
private SingletonHungry() {
}
/** * 不存在线程安全的问题 */ public static SingletonHungry getInstance() { return singletonHungry; } } |
懒汉式
|
/** * 懒汉式：需要用才创建 */ class SingletonLazy {
private static SingletonLazy singletonLazy = null;
private SingletonLazy() {
} /** * 存在线程安全问题 */ public static SingletonLazy getInstance() { // public static synchronized SingletonLazy getInstance() { if(null == singletonLazy) { singletonLazy = new SingletonLazy(); } return singletonLazy; } } /** * 推荐用：静态内部类，解决线程安全问题 * 原理： * 外部类加载时，并不需要立即加载内部类，内部类不被加载则不去初始化，所以不占内存， * 只有当getInstance()被调用时，JVM才会加载Inside类。 * JVM在多线程环境下初始化一个类，那么只有有一个线程去执行这个类的方法， * 其他线程会阻塞，即同一个加载器下，一个类型只会被初始化一次，这种阻塞往往是很隐蔽的。 * 所以可以看到Inside在创建过程是线程安全的，所以说静态内部类形式的单例可保证线程安全，也保证了单例的唯一性，同时也延迟了单例的实例化。 */ class SingletonInside {
public static class Inside { private static final SingletonInside SINGLETON_INSIDE = new SingletonInside(); }
private SingletonInside() {
}
public static SingletonInside getInstance() { return Inside.SINGLETON_INSIDE; } } /** * 双检查机制 */ class SingletonDoubleCheck {
private static SingletonDoubleCheck singletonDoubleCheck = null;
public static SingletonDoubleCheck getInstance() { if(null == singletonDoubleCheck) { synchronized (SingletonDoubleCheck.class) { singletonDoubleCheck = new SingletonDoubleCheck(); } } return singletonDoubleCheck; } } |