JAVA 并发实现六(Volatile的使用)

Java™ 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量。

这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile 变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。

在JDK1.2之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，就需要把变量声明为volatile（也可以使用同步，参见http://blog.csdn.net/ns_code/article/details/17288243），这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下，各任务间共享的变量都应该加volatile修饰符。

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

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才将私有拷贝与共享内存中的原始值进行比较。

这样当多个线程同时与某个对象交互时，就必须注意到要让线程及时的得到共享成员变量的变化。而volatile关键字就是提示JVM：对于这个成员变量，不能保存它的私有拷贝，而应直接与共享成员变量交互。

volatile是一种稍弱的同步机制，在访问volatile变量时不会执行加锁操作，也就不会执行线程阻塞，因此volatilei变量是一种比synchronized关键字更轻量级的同步机制。

使用建议：

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

由于使用volatile屏蔽掉了JVM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

• 对变量的写操作不依赖于当前值。
• 该变量没有包含在具有其他变量的不变式中。

package com.subject01;

public class VolatileDemo extends Object implements Runnable {
	//value变量没有被标记为volatile
	private int value;
	//missedIt变量被标记为volatile
	private volatile boolean missedIt;
	//creationTime不需要声明为volatile，因为代码执行中它没有发生变化
	private long creationTime; 

	public VolatileDemo() {
		value = 10;
		missedIt = false;
		//获取当前时间，亦即调用Volatile构造函数时的时间
		creationTime = System.currentTimeMillis();
	}

	public void run() {
		print("entering run()");

		//循环检查value的值是否不同
		while ( value < 20 ) {
			//如果missedIt的值被修改为true，则通过break退出循环
			if  ( missedIt ) {
				//进入同步代码块前，将value的值赋给currValue
				int currValue = value;
				//在一个任意对象上执行同步语句，目的是为了让该线程在进入和离开同步代码块时，
				//将该线程中的所有变量的私有拷贝与共享内存中的原始值进行比较，
				//从而发现没有用volatile标记的变量所发生的变化
				Object lock = new Object();
				synchronized ( lock ) {
					//不做任何事
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				//离开同步代码块后，将此时value的值赋给valueAfterSync
				int valueAfterSync = value;
				print("in run() - see value=" + currValue +", but rumor has it that it changed!");
				print("in run() - valueAfterSync=" + valueAfterSync);
				break;
			}
		}
		print("leaving run()");
	}

	public void workMethod() throws InterruptedException {
		print("entering workMethod()");
		print("in workMethod() - about to sleep for 2 seconds");
		Thread.sleep(2000);
		//仅在此改变missedIt的值
		missedIt = true;
		print("in workMethod() - just set missedIt=" + missedIt);
		print("in workMethod() - about to sleep for 3 seconds");
	//	Thread.sleep(5000);
		//仅在此改变value的值
		value = 50;
		print("in workMethod() - just set value=" + value);
		print("in workMethod() - about to sleep for 5 seconds");

		Thread.sleep(3000);
		print("leaving workMethod()");
	}

/*
*该方法的功能是在要打印的msg信息前打印出程序执行到此所化去的时间，以及打印msg的代码所在的线程
*/
	private void print(String msg) {
		//使用java.text包的功能，可以简化这个方法，但是这里没有利用这一点
		long interval = System.currentTimeMillis() - creationTime;
		String tmpStr = "    " + ( interval / 1000.0 ) + "000";
		int pos = tmpStr.indexOf(".");
		String secStr = tmpStr.substring(pos - 2, pos + 4);
		String nameStr = "        " + Thread.currentThread().getName();
		nameStr = nameStr.substring(nameStr.length() - 8, nameStr.length());
		System.out.println(secStr + " " + nameStr + ": " + msg);
	}

	public static void main(String[] args) {
		try {
			//通过该构造函数可以获取实时时钟的当前时间
			VolatileDemo vol = new VolatileDemo();

			//稍停100ms，以让实时时钟稍稍超前获取时间，使print（）中创建的消息打印的时间值大于0
			Thread.sleep(100);  

			Thread t = new Thread(vol);
			t.start();

			//休眠100ms，让刚刚启动的线程有时间运行
			Thread.sleep(100);
			//workMethod方法在main线程中运行
			vol.workMethod();
		} catch ( InterruptedException x ) {
			System.err.println("one of the sleeps was interrupted");
		}
	}
}

　　参考的帖子及文章

http://blog.csdn.net/ns_code/article/details/17101369

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html  （写的相当的好）