`

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为止,也就是出现数据不同步. 

Java代码  收藏代码
  1. public class NonSafeThread implements Runnable {  
  2.   
  3.     /** 共享资源, 每个线程执行完之后加 1 */  
  4.     private volatile int volatileCount = 0;  
  5.   
  6.     public void run() {  
  7.   
  8.         /* 
  9.          * 每个线程调用sum100()方法,1000次 
  10.          */  
  11.   
  12.         for (int i = 1; i <= 1000; i++) {  
  13.             sum100();  
  14.         }  
  15.   
  16.         /* 
  17.          * 计算完毕之后, volatileCount 加 1 
  18.          */  
  19.   
  20.         increase();  
  21.     }  
  22.       
  23.     private void increase()  
  24.     {  
  25.         volatileCount++;  
  26.     }  
  27.   
  28.     /** 
  29.      * 对 1 到 100 求和 
  30.      */  
  31.     private int sum100() {  
  32.         int result = 0;  
  33.         for (int i = 1; i <= 100; i++) {  
  34.             result += i;  
  35.         }  
  36.         return result;  
  37.     }  
  38.   
  39.     /** 
  40.      * @return the volatileCount 
  41.      */  
  42.     public int getVolatileCount() {  
  43.         return volatileCount;  
  44.     }  
  45.   
  46. }  



Java代码  收藏代码
  1. /** 
  2.  * @author Eric 
  3.  *  
  4.  * @version 1.0 
  5.  */  
  6.   
  7. public class NonSafeThreadTest {  
  8.   
  9.     public static void main(String[] args) {  
  10.   
  11.         /** 记录循环次数 */  
  12.         int loopCount = 0;  
  13.   
  14.         /** 以main函数主线程创建一个是线程组 */  
  15.         ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();  
  16.   
  17.         for (;;) {  
  18.             loopCount++;  
  19.   
  20.             /* 
  21.              * 启动500个线程,初始化的线程会添加到当前线程组中 
  22.              */  
  23.             NonSafeThread nonSafeThread = new NonSafeThread();  
  24.             startThreads(nonSafeThread);  
  25.   
  26.             /* 
  27.              * 如果线程组中除了主线程之外,还有其它线程,则休眠5毫秒,然后再判断线程组中 剩余的线程数,直到只剩下主线程一个为止。 
  28.              */  
  29.             while (!isOnlyMainThreadLeft(threadGroup)) {  
  30.                 sleep(5);  
  31.             }  
  32.   
  33.             /* 
  34.              * 500个线程运行完毕,那么此时的volatile变量volatileCount的值应该500, 因为每个线程将其值加1。 
  35.              *  
  36.              * 验证是否出现线程不安全的情况。 
  37.              */  
  38.             validate(loopCount, nonSafeThread.getVolatileCount(), 500);  
  39.         }  
  40.     }  
  41.   
  42.     /** 
  43.      * 启动500个线程 
  44.      */  
  45.     private static void startThreads(NonSafeThread nonSafeThread) {  
  46.   
  47.         for (int i = 0; i < 500; i++) {  
  48.             new Thread(nonSafeThread).start();  
  49.         }  
  50.     }  
  51.   
  52.     /** 
  53.      * 验证是否出现线程不安全的情况。 如果是,则打印出线程不安全的信息。 
  54.      */  
  55.     private static void validate(int loopCount, int actualValue,  
  56.             int expectedValue) {  
  57.         if (!isVolatileCountExpected(actualValue, expectedValue)) {  
  58.             printNonSafeMessage(loopCount, actualValue, expectedValue);  
  59.             /* 
  60.              * 正常退出程序。 
  61.              */  
  62.             System.exit(0);  
  63.         }  
  64.     }  
  65.   
  66.     /** 
  67.      * 在控制台打印出现线程不安全时的信息。 
  68.      */  
  69.     private static void printNonSafeMessage(int loopCount, int actualValue,  
  70.             int expectedValue) {  
  71.         System.out.println(String.format(  
  72.                 "第%d次循环,出现线程不安全的情况,volatile的值不正确,期望值是%d, 但是500个线程运行的情况下是%d",  
  73.                 loopCount, expectedValue, actualValue));  
  74.     }  
  75.   
  76.     /** 
  77.      * 判断实际中的volatile值与期望值是否一致。 
  78.      */  
  79.     private static boolean isVolatileCountExpected(int actualValue,  
  80.             int expectedValue) {  
  81.         return actualValue == expectedValue;  
  82.     }  
  83.   
  84.     /** 
  85.      * 让线程休眠millis毫秒 
  86.      */  
  87.     private static void sleep(long millis) {  
  88.         try {  
  89.             Thread.sleep(millis);  
  90.         } catch (InterruptedException e) {  
  91.             // TODO Auto-generated catch block  
  92.             e.printStackTrace();  
  93.         }  
  94.     }  
  95.   
  96.     /** 
  97.      * 判断一个线程组是否只剩下主线程了。 
  98.      *  
  99.      * 如果是则返回true,如果不是则放回false. 
  100.      */  
  101.     private static boolean isOnlyMainThreadLeft(ThreadGroup tg) {  
  102.         return tg.activeCount() == 1;  
  103.     }  
  104.   
  105. }  


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

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

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

Java代码  收藏代码
  1. public void run() {  
  2.   
  3.         lock.lock();  
  4.   
  5.         try {  
  6.             /* 
  7.              * 每个线程调用sum100()方法,1000次 
  8.              */  
  9.   
  10.             for (int i = 1; i <= 1000; i++) {  
  11.                 sum100();  
  12.             }  
  13.   
  14.             /* 
  15.              * 计算完毕之后, volatileCount 加 1 
  16.              */  
  17.   
  18.             increase();  
  19.               
  20.         } finally {  
  21.             lock.unlock();  
  22.         }  
  23.   
  24.     }  



2. 使用synchronized 

Java代码  收藏代码
  1. public void run() {  
  2.   
  3.         synchronized ("") {  
  4.             /* 
  5.              * 每个线程调用sum100()方法,1000次 
  6.              */  
  7.   
  8.             for (int i = 1; i <= 1000; i++) {  
  9.                 sum100();  
  10.             }  
  11.   
  12.             /* 
  13.              * 计算完毕之后, volatileCount 加 1 
  14.              */  
  15.   
  16.             increase();  
  17.         }  
  18.     }  



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

分享到:
评论

相关推荐

    Java并发编程:volatile关键字解析

    ### Java并发编程:volatile关键字解析 #### 一、内存模型的相关概念 在深入了解`volatile`关键字之前,我们首先需要理解计算机内存模型的一些基本概念。在现代计算机系统中,CPU为了提高执行效率,会将频繁访问的...

    Java并发编程_设计原则和模式(CHM)

    Java并发编程是软件开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。本资源"Java并发编程_设计原则和模式(CHM)"聚焦于Java语言在并发环境下的编程技巧、...

    Java 并发编程:设计原则与模式

    本资料“Java并发编程:设计原则与模式”深入探讨了这些关键主题。 首先,我们需要理解Java并发编程的基础概念。Java中的并发是通过线程实现的,线程是程序执行的最小单位。Java提供了多种创建和管理线程的方法,如...

    Java 并发编程实战.pdf

    书中会首先介绍Java并发编程的基础知识,包括线程的创建和运行,同步机制的基本用法,以及Java内存模型的相关概念。随着章节的深入,作者可能会更深入地讲解Java提供的并发工具,例如锁、原子变量、线程池、以及并发...

    java并发编程2

    以上知识点覆盖了Java并发编程的主要方面,包括线程管理、同步机制、并发工具、设计模式、并发集合以及并发编程的最佳实践等,是理解和掌握Java并发编程的关键。在实际开发中,理解和熟练运用这些知识可以编写出高效...

    《java 并发编程实战高清PDF版》

    锁是Java并发编程中用于同步的关键工具。书中深入剖析了各种锁机制,如内置锁(也称为监视器锁),通过`synchronized`关键字实现。此外,还介绍了高级的锁接口`java.util.concurrent.locks`,如`ReentrantLock`,它...

    JAVA并发编程艺术pdf版

    通过深入学习《JAVA并发编程艺术》,开发者能更好地理解并发编程的原理,熟练运用Java提供的并发工具和API,解决实际开发中的多线程问题,提高软件的性能和稳定性。这是一本值得每一位Java开发者研读的书。

    java并发编程书籍

    2. **同步机制**:Java并发编程的核心在于同步,以防止数据不一致性和资源竞争。`synchronized`关键字用于实现临界区的互斥访问,确保同一时刻只有一个线程执行特定代码块。此外,还有`wait()`, `notify()`, `...

    java并发编程内部分享PPT

    总的来说,这份“java并发编程内部分享PPT”涵盖了Java并发编程的多个重要方面,包括线程创建与管理、同步机制、并发容器、线程池、并发问题以及异步计算。通过深入学习和实践这些知识点,开发者可以更好地应对多...

    java并发编程:设计与模式

    Java并发编程是计算机科学中一个复杂而重要的领域,主要关注如何在Java程序中合理地使用多线程以及同步机制来提高程序执行的效率和响应性。在Java中,并发编程不仅仅是关于多线程,它还涉及到内存管理、线程调度、...

    java并发编程与实践

    "Java并发编程与实践"文档深入剖析了这一主题,旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元(如CPU)中同时执行两个或更多任务的能力。在Java中,这主要通过线程来实现,...

    Java并发编程实践高清pdf及源码

    《Java并发编程实践》是一本深入探讨Java多线程编程的经典著作,由Brian Goetz、Tim Peierls、Joshua Bloch、Joseph Bowles和David Holmes等专家共同编写。这本书全面介绍了Java平台上的并发编程技术,是Java开发...

    Java 并发编程:volatile的使用及其原理解析

    Java并发编程中的volatile关键字是一个非常重要的工具,它用于解决多线程环境下的可见性和有序性问题,但不保证原子性。在《Java并发编程:核心理论》中提到了并发编程中遇到的三大挑战:可见性、有序性以及原子性。...

    Java 并发核心编程

    1. **Volatile**: `volatile`关键字可以用来确保变量的写入立即对其他线程可见,但不保证原子性。 2. **Synchronized**: `synchronized`关键字可以用来同步方法或代码块,确保同一时刻只有一个线程可以访问特定代码...

    JAVA并发编程实践.pdf+高清版+目录 书籍源码

    《JAVA并发编程实践》这本书是Java开发者深入理解并发编程的重要参考资料。它涵盖了Java并发的核心概念、工具和最佳实践,旨在帮助读者在多线程环境下编写高效、安全的代码。 并发编程是现代软件开发中的关键技能,...

    Java并发编程:volatile关键字详细解析

    Java并发编程中的volatile关键字是一个非常重要的工具,用于处理多线程环境下的共享变量同步问题。在Java 5之前,volatile的使用常常导致不可预测的行为,但在Java 5之后,随着Java内存模型(JMM,Java Memory Model...

    java并发编程

    Java并发编程是Java开发者必须掌握的关键技能之一,它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的计算能力,提高应用程序的响应速度和整体性能。《Java编程并发实战》这本书是...

    一本经典的多线程书籍 Java并发编程 设计原则与模式 第二版 (英文原版)

    - volatile关键字:保证数据在多线程环境中的可见性。 - synchronized关键字:用于实现线程互斥,确保共享资源的正确访问。 3. **设计原则与模式** - 原子性:操作不可分割,要么全部完成,要么都不完成。 - ...

    Java并发编程书籍高清版

    本资源包含三本权威的Java并发编程书籍:《Java并发编程实践》、《java并发编程的艺术》以及Brian Goetz的文字版《Java并发编程实践》。 首先,我们来看《Java并发编程实践》(Java Concurrency in Practice)这...

    Java并发编程设计原则和模式

    本资料“Java并发编程设计原则和模式”深入探讨了如何在Java环境中有效地进行并发处理,以充分利用系统资源并避免潜在的并发问题。 一、并发编程基础 并发是指两个或多个操作在同一时间段内执行,但并不意味着这些...

Global site tag (gtag.js) - Google Analytics