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); // 将单例放入当前线程的局部变量中
}
}