一味药引：手撕单例

在撕单例的时候引发的故事…

public class TestSingleton {
	private String name = null;
	private TestSingleton() {};
	
	private static volatile TestSingleton instance = null;
	//双重检查锁定
	public static TestSingleton getSingleton() {
		if(instance == null) {
			synchronized (TestSingleton.class) {
				if(instance == null) {
					instance = new TestSingleton();
				}
			}
		}
		return instance;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void printName() {
		System.out.println("My name is "+name);
	}
}

测试类

public class TestMain {

	public static void main(String[] args) {
		TestSingleton single1 = TestSingleton.getSingleton();
		single1.setName("单例1");
		TestSingleton single2 = TestSingleton.getSingleton();
		single2.setName("单例2");
		
		single1.printName();
		single2.printName();
		
		if(single1 == single2) {
			System.out.println("同一个对象");
		}else {
			System.out.println("不是同一个对象");
		}
	}
	/*结论：由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点
	 * 不管它实现何种功能，整个应用程序都会同享一个实例对象
	 * */
}

结果：

疑问在这…

为何需要加上volatile？

Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的，无论是普通变量还是volatile变量都是如此，普通变量与volatile变量的区别是，volatile的特殊规则保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。因此，可以说volatile保证了多线程操作时变量的可见性，而普通变量则不能保证这一点
volatile详解
每个线程访问一个volatile作用域时会在继续执行之前读取它的当前值，而不是（可能）使用一个缓存的值

搜到的原因如下：

不加 volatile 的情况下，假设两个线程，线程A正在执行instance = new Instance()的操作，而线程B开始执行if（instance==null）的判断，当不存在volatile的时候，因为 new Instance()是一个非原子操作，可能发生无序写入，构造函数可能在整个对象构造完成前执行完毕，线程B可能会看到一个不完整的instance对象，因为java的某些实现会在内存中开辟一片存储对象的区域后直接返回内存的引用，所以线程B判断不为null，而这时候实际上，instance的构造函数还没有执行，从而线程b得到不完整的对象。在 Instance 的构造函数执行之前，会在内存中开辟一片存储对象的区域后直接返回内存的引用，赋值给变量 instance，instance也就可能成为非 null 的，即赋值语句在对象实例化之前调用，此时别的线程得到的是一个还未初始化的对象，这样会导致系统崩溃线程B可能会看到一个不完整的instance对象，因为java的某些实现，所以线程B判断不为null。从而得到不完整的对象

好家伙… 不懂原子性与非原子性…
上百度百科ing…

原子性（atomicity）指事务的不可分割性
一个事务的所有操作要么不间断地全部被执行，要么一个也没有执行
所谓原子操作,就是”不可中断的一个或一系列操作”

再查…

CPU的CAS操作保证了原子性

好家伙…CAS又是啥

CAS，全称Compare-and-Swap，是指比较和交换，一种特殊的处理器指令
CAS详解博文

不加上volatile情况下

public class TestSingleton {
	private String name = null;
	private TestSingleton() {};
	
	private static TestSingleton instance = null;
	//双重检查锁定
	public static TestSingleton getSingleton() {
		if(instance == null) {
			synchronized (TestSingleton.class) {
				if(instance == null) {
					instance = new TestSingleton();
				}
			}
		}
		return instance;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void printName() {
		System.out.println("My name is "+name);
	}
}

这段代码是单例的双重检测机制实现，很多人觉得这个代码是没问题的。在大多数情况，这段代码确实没问题，但在极端的情况下，有个隐藏的问题

分析

假设有两个线程同时访问这段代码，此时线程A走到 instance = new TestSingleton() 开始初始化对象，线程B则刚走到 if(instance == null) 进行第一次检测。这时要介绍下 instance = new TestSingleton() 初始化这行代码，这行代码虽然只有一句话，但是被编译后会变成以下3条指令

memory = allocate（）;    // 1.分配对象的内存空间
ctorInstance（memory）;    // 2.初始化对象
instance = memory;    // 3.设置instance指向刚才分配的内存地址

正常情况下，这3条执行时按顺序执行，双重检测机制就没有问题。但是CPU内部会在保证不影响最终结果的前提下对指令进行重新排序（不影响最终结果只是针对单线程，切记），指令重排的主要目的是为了提高效率。在本例中，如果这3条指令被重排成以下顺序

memory = allocate（）;    // 1.分配对象的内存空间
instance = memory;    // 3.设置instance指向刚才分配的内存地址
ctorInstance（memory）;    // 2.初始化对象

如果线程A执行完1和3，instance对象还未完成初始化，但是已经不再指向null。此时线程B抢占到CPU资源，执行 if(instance == null) 的检测结果为false，则执行return instance;，从而返回一个还未初始化完成的instance对象，从而出导致问题出现。要解决这个问题，只需要使用volatile关键字修饰instance对象即可

原子性插曲

看到一篇 java中long和double类型操作的非原子性探究
文中信息
Java中的原子操作包括：
1）除long和double之外的基本类型的赋值操作
2）所有引用reference的赋值操作
3）java.concurrent.Atomic.* 包中所有类的一切操作。

但是java对long和double的赋值操作是非原子操作！！long和double占用的字节数都是8，也就是64bits。 在32位操作系统上对64位的数据的读写要分两步完成，每一步取32位数据。这样对double和long的赋值操作就会有问题：如果有两个线程同时写一个变量内存，一个进程写低32位，而另一个写高32位，这样将导致获取的64位数据是失效的数据。因此需要使用volatile关键字来防止此类现象。 volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的

在目前intel平台的x64 hotspot jvm中，long 、double的访问是原子的