Java并发编程

1、Java并发编程：Volatile不能保证数据同步在本篇博文中,将给出一个实例去验证volatile修饰的变量并不能保证其数据同步。在本篇博文中,将给出一个实例去验证volatile修饰的变量并不能保证其数据同步。Java内存模型规定了所有变量都存储在主内存中，每条线程都有自己的工作内存，线程的工作内存保存了被该线程使用到变量的主内存副本拷贝，线程 对变量的所有操作(读取,赋值等)都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程也不能直接访问对方工作内存中的变量，线程间变量值的 传递均需要通过主内存来完成，线程，主内存，工作内存三者的交互关系如图所示。当一个变量定义成volati

2、le之后, 保证了此变量对所有线程的可见性,也就是说当一条线程修改了这个变量的值,新的值对于其它线程来说是可以立即得知的.此时,该变量的读写操作直接在主内存中完成.Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。Volatile variables share the visibility features of synchronized, but none of the atomicity features.虽然增量操作（x+）看上去类似一个单独操作，实际上它是一个由读取修改写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供

3、必须的原子特性。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并不能保证数据同步.下面将给出一个实例:实例 =>

4、; 500个线程一起运行,每个线程对1到100求和1000次操作,然后将一个volatile共享变量值加1. 当500个线程都完成操作之后, 期望的值是500,因为每个线程执行完毕之后都会对这个volatile变量加1.一直循环执行这个程序,直到出现volatile变量的值小于500为止,也就是出现数据不同步。1. public class NonSafeThread implements Runnable  2.  3.     /* 共享资源, 每个线程执行完之

5、后加 1 */ 4.     private volatile int volatileCount = 0; 5.  6.     public void run()  7.  8.         /* 9.      

6、0;   * 每个线程调用sum100()方法，1000次 10.          */ 11.  12.         for (int i = 1; i <= 1000; i+)  13.     

7、0;       sum100(); 14.          15.  16.         /* 17.          * 计算完毕之后， volatileCount 加 1 18

8、.          */ 19.  20.         increase(); 21.      22.      23.     private void increase() 24.    

9、  25.         volatileCount+; 26.      27.  28.     /* 29.      * 对 1 到 100 求和 30.      */ 31.  

10、0;  private int sum100()  32.         int result = 0; 33.         for (int i = 1; i <= 100; i+)  34.   

11、0;         result += i; 35.          36.         return result; 37.      38.  39.     /* 4

12、0.      * return the volatileCount 41.      */ 42.     public int getVolatileCount()  43.         return volatileCount; 44.   

13、;   45.  46.  1. /* 2.  * author Eric 3.  *  4.  * version 1.0 5.  */ 6.  7. public class NonSafeThreadTest  8.  9.     public static void m

14、ain(String args)  10.  11.         /* 记录循环次数 */ 12.         int loopCount = 0; 13.  14.         /* 以main函数主线程创建一个是线

15、程组 */ 15.         ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); 16.  17.         for (;)  18.          &

16、#160;  loopCount+; 19.  20.             /* 21.              * 启动500个线程，初始化的线程会添加到当前线程组中 22.         

17、     */ 23.             NonSafeThread nonSafeThread = new NonSafeThread(); 24.             startThreads(nonSafeThread); 

18、25.  26.             /* 27.              * 如果线程组中除了主线程之外，还有其它线程，则休眠5毫秒，然后再判断线程组中 剩余的线程数，直到只剩下主线程一个为止。 28.        &#

19、160;     */ 29.             while (!isOnlyMainThreadLeft(threadGroup)  30.                 sleep(5); 31.  

20、;            32.  33.             /* 34.              * 500个线程运行完毕，那么此时的volatile变量volatileCount的值应该5

21、00， 因为每个线程将其值加1。 35.              *  36.              * 验证是否出现线程不安全的情况。 37.           

22、0;  */ 38.             validate(loopCount, nonSafeThread.getVolatileCount(), 500); 39.          40.      41.  42.    

23、60;/* 43.      * 启动500个线程 44.      */ 45.     private static void startThreads(NonSafeThread nonSafeThread)  46.  47.         for 

24、(int i = 0; i < 500; i+)  48.             new Thread(nonSafeThread).start(); 49.          50.      51.  52.

25、     /* 53.      * 验证是否出现线程不安全的情况。 如果是，则打印出线程不安全的信息。 54.      */ 55.     private static void validate(int loopCount, int actualValue, 56.   

26、          int expectedValue)  57.         if (!isVolatileCountExpected(actualValue, expectedValue)  58.             

27、;printNonSafeMessage(loopCount, actualValue, expectedValue); 59.             /* 60.              * 正常退出程序。 61.      

28、0;       */ 62.             System.exit(0); 63.          64.      65.  66.     /* 67.  

29、60;   * 在控制台打印出现线程不安全时的信息。 68.      */ 69.     private static void printNonSafeMessage(int loopCount, int actualValue, 70.            &

30、#160;int expectedValue)  71.         System.out.println(String.format( 72.                 "第%d次循环，出现线程不安全的情况，volatile的值不正确,期望值是%d, 但是500个线程运行的情况下是%d&

31、quot;, 73.                 loopCount, expectedValue, actualValue); 74.      75.  76.     /* 77.      * 判断实际中的volati

32、le值与期望值是否一致。 78.      */ 79.     private static boolean isVolatileCountExpected(int actualValue, 80.             int expectedValue)  81.  &#

33、160;      return actualValue = expectedValue; 82.      83.  84.     /* 85.      * 让线程休眠millis毫秒 86.      */ 87.    

34、 private static void sleep(long millis)  88.         try  89.             Thread.sleep(millis); 90.         &#

35、160;catch (InterruptedException e)  91.             / TODO Auto-generated catch block 92.             e.printStackTrace(); 93.

36、60;        94.      95.  96.     /* 97.      * 判断一个线程组是否只剩下主线程了。 98.      *  99.      * 如果是则返回true，如果不是则放

37、回false. 100.      */ 101.     private static boolean isOnlyMainThreadLeft(ThreadGroup tg)  102.         return tg.activeCount() = 1; 103.    

38、;  104.  105.  某次运行,输出的结果如下：第83次循环，出现线程不安全的情况，volatile的值不正确,期望值是500, 但是500个线程运行的情况下是499在这种情况下,可以通过 Lcak和synchronized来保证数据的同步。如:1. 使用Lock,修改NonSafeThread类的run方法的内容：1. public void run()  2.  3.         lock.lock();

39、60;4.  5.         try  6.             /* 7.              * 每个线程调用sum100()方法，1000次 8.    &#

40、160;         */ 9.  10.             for (int i = 1; i <= 1000; i+)  11.           

41、      sum100(); 12.              13.  14.             /* 15.            

42、60; * 计算完毕之后， volatileCount 加 1 16.              */ 17.  18.             increase(); 19.        

43、;      20.          finally  21.             lock.unlock(); 22.          23.  24.      2. 使用synchronized 1. public void run()  2. &