我讲设计模式--单例模式
?
/**
?* 单例之一 ---普通单例
?*?
?* 就是考虑到 线程并发问题。。。你这个demo ?只能算是 普通的 singleton。。
?* 优点：能要用的时候才实例化对象，避免不必要加载实例开销
?* 缺点：并发的时候 效率底下，同步一个方法可能造成程序执行效率下降100倍
?*?
?* 适用场景：已经有很多创建实例的情况下
?*?
?* 说明： 其实同步只有第一次执行此方法时，才真正需要同步。之后每次调用这个
?* 方法，同步就变成了累赘
?*/
public class Singleton1 {
// 单列对象
private static Singleton1 uniqueInstance;
private Singleton1() {}
// 通过synchronized，迫使每个线程在进入这个方法前，要先等候别的线程
// 离开改方法，即不可能有两个线程同时进入该方法
public static synchronized Singleton1 getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton1();
}
return uniqueInstance;
}
}
?
?
?
?
?
/**
?* 单列模式之二 --- 急切模式
?*?
?* 优点：不会有synchronized 同步情况下效率低下问题
?* 缺点：如果 程序加载的 实例 比较多。。加载的时候。。要在加 n 多个实例的
?*?
?* 适用场景：在创建和运行时方面的负担不太繁重，你就可能要创建这种单例
?*?
?* 说明: 依赖JVM在加载这个类时马上创建此唯一的实例。JVM保证任何线程访问
?* uniqueInstance 静态变量之前，一定先创建此单列
?*/
public class Singleton2 {
// 单列对象
// 在静态初始化器中创建单件。这段代码保证了线程安全
private static Singleton2 uniqueInstance = new Singleton2();
private Singleton2() {}
public static Singleton2 getInstance() {
// 已经有实例直接使用
return uniqueInstance;
}
}
?
?
?
?
/**
?* 单列模式之三 --- 双重锁检查
?*?
?* 优点 ：这种方式 解决了每次调用getInstance 效率底下的问题
?* ? ? ? 也不会在每次加载，实例对象问题
?* 缺点： 必须在jdk1.5或以上才能用，以下的使用关键字volatile实现
?* ? ? ? 会导致双重检查失效。
?*?
?* 场景：解决了上面两个的问题，单一定要确保是在jdk1.5或以上的版本使用
?*/
public class Singleton3 {
// 单列对象
// volatile用在多线程中，volatile修饰的成员变量在每次被线程访问时，
// 都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，
// 强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。?
private volatile static Singleton3 uniqueInstance;
private Singleton3() {}
public static Singleton3 getInstance() {
// 检查时如果不存在，就进入同步区块
// 只有第一次实例才会彻底执行这里的代码
if (uniqueInstance == null) {
synchronized (Singleton3.class) {
// 进入区块后，再检查一次。如果仍是null，才创建实例
if (uniqueInstance == null) {
uniqueInstance = new Singleton3();
}
}
}
return uniqueInstance;
}
}
?
