Java 实现单列模式

Java 实现单列模式

饿汉式单例模式

public class HungryChinesesinglecase {
// 指向自己实例的私有静态引用，主动创建
private static HungryChinesesinglecase singleton = new HungryChinesesinglecase();

// 私有的构造方法
private HungryChinesesinglecase(){
	System.out.println("饿汉式单例模式被创建了");
}
// 以自己实例为返回值的静态的公有方法，静态工厂方法
/**
 * @return
 */
public static HungryChinesesinglecase getHungryChinesesinglecase(){
    return singleton;
}

//总结：类加载的方式是按需加载，且加载一次。。因此，在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用；而且，由于这个类在整个生命周期中只会被加载一次，因此只会创建一个实例，即能够充分保证单例。

@Override
public String toString() {
	return "HungryChinesesinglecase [getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()="
			+ super.toString() + "]";
}

}

懒汉单列模式

public class Lazysinglecase {
// 指向自己实例的私有静态引用
private static Lazysinglecase singleton;

// 私有的构造方法
private Lazysinglecase(){
	System.out.println("懒汉式单例模式被创建了");
}

// 以自己实例为返回值的静态的公有方法，静态工厂方法
public static Lazysinglecase getLazysinglecase(){
    // 被动创建，在真正需要使用时才去创建
    if (singleton == null) {
        singleton = new Lazysinglecase();
    }
    return singleton;
}

}

双重检测单列模式（线程安全）

public class LazysinglecaseDoubleCheckidiom {
//使用volatile关键字防止重排序，因为 new Instance()是一个非原子操作，可能创建一个不完整的实例
private static volatile LazysinglecaseDoubleCheckidiom singleton;

private LazysinglecaseDoubleCheckidiom() {
}

public static LazysinglecaseDoubleCheckidiom getLazysinglecaseDoubleCheckidiom() {
    // Double-Check idiom
    if (singleton == null) {
        synchronized (LazysinglecaseDoubleCheckidiom.class) {       // 1
            // 只需在第一次创建实例时才同步
            if (singleton == null) {       // 2
                singleton = new LazysinglecaseDoubleCheckidiom();      // 3
            }
        }
    }
    return singleton;
}

}

内部类单列模式（线程安全）

public class Lazysinglecaseinerclass {
// 私有内部类，按需加载，用时加载，也就是延迟加载
private static class Holder {
private static Lazysinglecaseinerclass singleton = new Lazysinglecaseinerclass();
}

private Lazysinglecaseinerclass() {

}

public static Lazysinglecaseinerclass getLazysinglecaseinerclass() {
    return Holder.singleton;
}

}

synchronized的使用 改写懒汉单列模式为线程安全

public class Lazysinglecasesynchronized {
private static Lazysinglecasesynchronized singleton;

private Lazysinglecasesynchronized(){}

// 使用 synchronized 修饰，临界资源的同步互斥访问

//同步延迟加载 — synchronized方法
public static synchronized Lazysinglecasesynchronized getLazysinglecasesynchronized(){
if (singleton == null) {
singleton = new Lazysinglecasesynchronized();
}
return singleton;
}
//同步延迟加载 — synchronized块
// public static Lazysinglecasesynchronized getLazysinglecasesynchronized(){
// synchronized(Lazysinglecasesynchronized.class){ // 使用 synchronized 块，临界资源的同步互斥访问
// if (singleton == null) {
// singleton= new Singleton();
// }
// }
// return singleton;
// }
//

}

ThreadLocal 的使用 改写懒汉单列模式为线程安全

public class LazysinglecaysThreadLocal {
// ThreadLocal 线程局部变量
private static ThreadLocal threadLocal = new ThreadLocal();
private static LazysinglecaysThreadLocal singleton = null; // 不需要是

private LazysinglecaysThreadLocal(){}

public static LazysinglecaysThreadLocal getSingleton4(){
    if (threadLocal.get() == null) {        // 第一次检查：该线程是否第一次访问
        createLazysinglecaysThreadLocal();
    }
    return singleton;
}

public static void createLazysinglecaysThreadLocal(){
    synchronized (LazysinglecaysThreadLocal.class) {
        if (singleton == null) {          // 第二次检查：该单例是否被创建
        	singleton = new LazysinglecaysThreadLocal();   // 只执行一次
        }
    }
    threadLocal.set(singleton);      // 将单例放入当前线程的局部变量中 

}
}

生活不易，适当救济