深入浅出设计模式五——独一无二(单例模式）

先看文章 ：http://quicker.iteye.com/blog/579948

 

public class Singleton {
	private Singleton(){}
	private static Singleton st = new Singleton();//这句话保证了线程安全。
	//在类加载的时候初始化，new出对象，也就是说每加载一次类就new 一次
	public static Singleton getInstance(){
		return st;
	}
	
}

class LazySingleton{
	private LazySingleton(){}
	private static LazySingleton st = null;
	//第一次加载，对st初始化为null,调用getInstance方法后，对st进行实例化。
	//以后再加载的时候会发现st已经指向了对象，直接执行return st.
	//要保证线程安全，必须加synchronized关键字。
	public static synchronized LazySingleton getInstance(){
		if(st == null)
			st =  new LazySingleton();
		return st;
	}
}


/*
 * 对第二种利用synchronized保证线程安全的情况进行改进，因为线程安全问题只出现在第一次调用getInstance方法时，
 * 当st被实例化之后，就不存在线程安全问题了。所以下例我们只在第一次调用getInstance方法时，并且st为空的时候才
 * 检查线程的安全性。注意volatile关键字的使用。这叫“双重检查加锁”，减少使用同步。
 */
class DoubleCheckSingleton{
	
	private DoubleCheckSingleton(){}
	private volatile static DoubleCheckSingleton st ;
	public static DoubleCheckSingleton getInstance(){
		if(st == null){
			synchronized (DoubleCheckSingleton.class) {
				if(st == null){
					st =  new DoubleCheckSingleton();
				}
			}
		}
	
		return st;
	}
}
class Test{
	public static void main(String[] args) {
		Singleton st1 = Singleton.getInstance();
		Singleton st2 = Singleton.getInstance();
		System.out.println(st1==st2);
		
		LazySingleton lzSt1 = LazySingleton.getInstance();
		LazySingleton lzSt2 = LazySingleton.getInstance();
		System.out.println(lzSt1==lzSt2);
		
		DoubleCheckSingleton dcs1 = DoubleCheckSingleton.getInstance();
		DoubleCheckSingleton dcs2 = DoubleCheckSingleton.getInstance();
		System.out.println(dcs1==dcs2);
	}
}

 关于关键字：volatile

　Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 

 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。 

 

在大多数情况下，把变量缓存在寄存器中是一个非常有价值的优化方法，如果不用的话很可惜。C和C++给你提供了显式禁用这种缓存优化的机会。如果你声明变量是使用了volatile修饰符，编译器就不会把这个变量缓存在寄存器里——每次访问都将去存取变量在内存中的实际位置
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字