Java并发编程: Volatile不能保证数据同步

在本篇博文中,将给出一个实例去验证volatile修饰的变量并不能保证其数据同步.

Java内存模型规定了所有变量都存储在主内存中，每条线程都有自己的工作内存，线程的工作内存保存了被该线程使用到变量的主内存副本拷贝，线程对变量的所有操作(读取,赋值等)都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程也不能直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成，线程，主内存，工作内存三者的交互关系如图所示。



当一个变量定义成volatile之后, 保证了此变量对所有线程的可见性,也就是说当一条线程修改了这个变量的值,新的值对于其它线程来说是可以立即得知的.此时,该变量的读写操作直接在主内存中完成.

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。
Volatile variables share the visibility features of synchronized, but none of the atomicity features.

虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。
While the increment operation (x++) may look like a single operation, it is really a compound read-modify-write sequence of operations that must execute atomically -- and volatile does not provide the necessary atomicity.

在多线程并发的环境下, 各个线程的读/写操作可能有重叠现象, 在这个时候, volatile并不能保证数据同步.

下面将给出一个实例:

实例 ==> 500个线程一起运行,每个线程对1到100求和1000次操作,然后将一个volatile共享变量值加1. 当500个线程都完成操作之后, 期望的值是500,因为每个线程执行完毕之后都会对这个volatile变量加1.

一直循环执行这个程序,直到出现volatile变量的值小于500为止,也就是出现数据不同步.

public class NonSafeThread implements Runnable {

	/** 共享资源, 每个线程执行完之后加 1 */
	private volatile int volatileCount = 0;

	public void run() {

		/*
		 * 每个线程调用sum100()方法，1000次
		 */

		for (int i = 1; i <= 1000; i++) {
			sum100();
		}

		/*
		 * 计算完毕之后， volatileCount 加 1
		 */

		increase();
	}
	
	private void increase()
	{
		volatileCount++;
	}

	/**
	 * 对 1 到 100 求和
	 */
	private int sum100() {
		int result = 0;
		for (int i = 1; i <= 100; i++) {
			result += i;
		}
		return result;
	}

	/**
	 * @return the volatileCount
	 */
	public int getVolatileCount() {
		return volatileCount;
	}

}

/**
 * @author Eric
 * 
 * @version 1.0
 */

public class NonSafeThreadTest {

	public static void main(String[] args) {

		/** 记录循环次数 */
		int loopCount = 0;

		/** 以main函数主线程创建一个是线程组 */
		ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();

		for (;;) {
			loopCount++;

			/*
			 * 启动500个线程，初始化的线程会添加到当前线程组中
			 */
			NonSafeThread nonSafeThread = new NonSafeThread();
			startThreads(nonSafeThread);

			/*
			 * 如果线程组中除了主线程之外，还有其它线程，则休眠5毫秒，然后再判断线程组中 剩余的线程数，直到只剩下主线程一个为止。
			 */
			while (!isOnlyMainThreadLeft(threadGroup)) {
				sleep(5);
			}

			/*
			 * 500个线程运行完毕，那么此时的volatile变量volatileCount的值应该500， 因为每个线程将其值加1。
			 * 
			 * 验证是否出现线程不安全的情况。
			 */
			validate(loopCount, nonSafeThread.getVolatileCount(), 500);
		}
	}

	/**
	 * 启动500个线程
	 */
	private static void startThreads(NonSafeThread nonSafeThread) {

		for (int i = 0; i < 500; i++) {
			new Thread(nonSafeThread).start();
		}
	}

	/**
	 * 验证是否出现线程不安全的情况。 如果是，则打印出线程不安全的信息。
	 */
	private static void validate(int loopCount, int actualValue,
			int expectedValue) {
		if (!isVolatileCountExpected(actualValue, expectedValue)) {
			printNonSafeMessage(loopCount, actualValue, expectedValue);
			/*
			 * 正常退出程序。
			 */
			System.exit(0);
		}
	}

	/**
	 * 在控制台打印出现线程不安全时的信息。
	 */
	private static void printNonSafeMessage(int loopCount, int actualValue,
			int expectedValue) {
		System.out.println(String.format(
				"第%d次循环，出现线程不安全的情况，volatile的值不正确,期望值是%d, 但是500个线程运行的情况下是%d",
				loopCount, expectedValue, actualValue));
	}

	/**
	 * 判断实际中的volatile值与期望值是否一致。
	 */
	private static boolean isVolatileCountExpected(int actualValue,
			int expectedValue) {
		return actualValue == expectedValue;
	}

	/**
	 * 让线程休眠millis毫秒
	 */
	private static void sleep(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 判断一个线程组是否只剩下主线程了。
	 * 
	 * 如果是则返回true，如果不是则放回false.
	 */
	private static boolean isOnlyMainThreadLeft(ThreadGroup tg) {
		return tg.activeCount() == 1;
	}

}

某次运行,输出的结果如下:
第83次循环，出现线程不安全的情况，volatile的值不正确,期望值是500, 但是500个线程运行的情况下是499

在这种情况下,可以通过 Lcak和synchronized来保证数据的同步.

如:
1. 使用Lock,修改NonSafeThread类的run方法的内容:

public void run() {

		lock.lock();

		try {
			/*
			 * 每个线程调用sum100()方法，1000次
			 */

			for (int i = 1; i <= 1000; i++) {
				sum100();
			}

			/*
			 * 计算完毕之后， volatileCount 加 1
			 */

			increase();
			
		} finally {
			lock.unlock();
		}

	}

2. 使用synchronized

public void run() {

		synchronized ("") {
			/*
			 * 每个线程调用sum100()方法，1000次
			 */

			for (int i = 1; i <= 1000; i++) {
				sum100();
			}

			/*
			 * 计算完毕之后， volatileCount 加 1
			 */

			increase();
		}
	}

如果用Lock或者synchronized修改了NonSafeThread类, 如果再想跑这个程序的话,需要控制一下NonSafeThreadTest中for循环中执行的次数,比如1000次 (我运行程序的时候,一般都在100次以内打印出数据不安全的结果),以免导致程序在Lock或者synchronized修改后一直执行下去.

评论

12 楼 MouseLearnJava 2013-08-06  

freezingsky 写道

哥们，把内存模型这一块研究完一起讲了，并发这一块就基本完成了！加油！

谢谢你的建议. 正在学习Java内存模型,以后会在博文中记录一些学习的内容.

在这之前,想先记录下 Semaphore 和 Exchanger的内容. 谢谢

11 楼 MouseLearnJava 2013-08-06  

wwy_0918 写道

anlystar 写道

楼主理解错了，
volatile是 原子变量 ，保证该变量在存取的时候是同步的，但是 "++" 并不是原子操作，在虚拟机底层“++”也是分几步实现的：先取、在计算、最后赋值，在这几步之间其他线程修改了该变量也会出现线程问题，volatile比较适用于一个线程更改，多条线程读取的情况，能保证在一条线程中更改了，其他线程能立即获取到最新的值，若是多条线程更改的情况，请使用AtomicInteger 或者AtomicLong等

这个是正确的

freezingsky 写道

volatile不能保证数据的同步，只能说它具有可见性。这里涉及的原因，与java的内存模型有关。同时，对于数据的操作，比如++或者--，这里就涉及到一些所谓的原语（PV）。记得java在并发包里用的是类似玩CAS（好像是compare and set?）的方式来完成非锁同步。

谢谢你们的指正和信息.

正是Java里面的运算并非原子操作,导致了volatile变量的运算在并发下产生了不安全.

10 楼 freezingsky 2013-08-05  

哥们，把内存模型这一块研究完一起讲了，并发这一块就基本完成了！加油！

9 楼 JavaSam 2013-08-05  

fisher123 写道

其实LZ想说volatile只是一种弱同布策略，对这个变量的操作必须是原子的，不然就会出现错误。
如果操作不是原子的，就必须用强同步措施，lock，synchronized等等。

好吧，错怪lz了

8 楼 wwy_0918 2013-08-05  

wwy_0918 写道

anlystar 写道

楼主理解错了，
volatile是 原子变量 ，保证该变量在存取的时候是同步的，但是 "++" 并不是原子操作，在虚拟机底层“++”也是分几步实现的：先取、在计算、最后赋值，在这几步之间其他线程修改了该变量也会出现线程问题，volatile比较适用于一个线程更改，多条线程读取的情况，能保证在一条线程中更改了，其他线程能立即获取到最新的值，若是多条线程更改的情况，请使用AtomicInteger 或者AtomicLong等

这个是正确的

楼主也没说错，都是一个意思 ，volidate只保证了多线程之间的可见性，不涉及同步性。正如

freezingsky 写道

volatile不能保证数据的同步，只能说它具有可见性。这里涉及的原因，与java的内存模型有关。同时，对于数据的操作，比如++或者--，这里就涉及到一些所谓的原语（PV）。记得java在并发包里用的是类似玩CAS（好像是compare and set?）的方式来完成非锁同步。

所说。

7 楼 JavaSam 2013-08-05  

没有人，也没有哪本书说volatile能保证数据同步！！

6 楼 wwy_0918 2013-08-05  

anlystar 写道

楼主理解错了，
volatile是 原子变量 ，保证该变量在存取的时候是同步的，但是 "++" 并不是原子操作，在虚拟机底层“++”也是分几步实现的：先取、在计算、最后赋值，在这几步之间其他线程修改了该变量也会出现线程问题，volatile比较适用于一个线程更改，多条线程读取的情况，能保证在一条线程中更改了，其他线程能立即获取到最新的值，若是多条线程更改的情况，请使用AtomicInteger 或者AtomicLong等

这个是正确的

5 楼 freezingsky 2013-08-05  

volatile不能保证数据的同步，只能说它具有可见性。这里涉及的原因，与java的内存模型有关。同时，对于数据的操作，比如++或者--，这里就涉及到一些所谓的原语（PV）。记得java在并发包里用的是类似玩CAS（好像是compare and set?）的方式来完成非锁同步。

4 楼 anlystar 2013-08-05  

楼主理解错了，
volatile是 原子变量 ，保证该变量在存取的时候是同步的，但是 "++" 并不是原子操作，在虚拟机底层“++”也是分几步实现的：先取、在计算、最后赋值，在这几步之间其他线程修改了该变量也会出现线程问题，volatile比较适用于一个线程更改，多条线程读取的情况，能保证在一条线程中更改了，其他线程能立即获取到最新的值，若是多条线程更改的情况，请使用AtomicInteger 或者AtomicLong等

3 楼 fisher123 2013-08-05  

其实LZ想说volatile只是一种弱同布策略，对这个变量的操作必须是原子的，不然就会出现错误。
如果操作不是原子的，就必须用强同步措施，lock，synchronized等等。

2 楼 michaellou 2013-08-05  

volatile不稳定

1 楼 sd6815892 2013-08-05  

楼主对volatile不具备原子性用代码阐述的很清楚，这个在很多地方都能看到,不过我想看到volatile的可见性也能用代码阐述，也就是比较有volatile和不用volatile的变量有什么不同