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

这篇文章将为大家详细讲解有关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 {           private volatile int volatileCount = 0;      public void run() {                    for (int i = 1; i <= 1000; i++) {             sum100();         }                    increase();     }          private void increase()     {         volatileCount++;     }           private int sum100() {         int result = 0;         for (int i = 1; i <= 100; i++) {             result += i;         }         return result;     }           public int getVolatileCount() {         return volatileCount;     }  }

  public class NonSafeThreadTest {      public static void main(String[] args) {                   int loopCount = 0;                   ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();          for (;;) {             loopCount++;                           NonSafeThread nonSafeThread = new NonSafeThread();             startThreads(nonSafeThread);                           while (!isOnlyMainThreadLeft(threadGroup)) {                 sleep(5);             }                           validate(loopCount, nonSafeThread.getVolatileCount(), 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));     }           private static boolean isVolatileCountExpected(int actualValue,             int expectedValue) {         return actualValue == expectedValue;     }           private static void sleep(long millis) {         try {             Thread.sleep(millis);         } catch (InterruptedException e) {             // TODO Auto-generated catch block             e.printStackTrace();         }     }           private static boolean isOnlyMainThreadLeft(ThreadGroup tg) {         return tg.activeCount() == 1;     }  }

某次运行,输出的结果如下：

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

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

如:

使用Lock,修改NonSafeThread类的run方法的内容：

public void run() {          lock.lock();          try {                           for (int i = 1; i <= 1000; i++) {                 sum100();             }                            increase();                      } finally {             lock.unlock();         }      }

使用synchronized

public void run() {          synchronized ("") {                           for (int i = 1; i <= 1000; i++) {                 sum100();             }                            increase();         }     }

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

关于java并发编程中Volatile不能保证数据同步就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。