Java中关于原子操作和volatile关键字

2015年08月19日 17:46:29

阅读数：2493

研究ThreadPoolExecutor的时候，发现其中大量使用了volatile变量。不知为何，因此做了一番查找，研究： 其中借鉴了很多网上资料。 在了解volatile变量作用前，先需要明白一些概念： 

什么是原子操作？ 
所谓原子操作,就是"不可中断的一个或一系列操作" , 在确认一个操作是原子的情况下，多线程环境里面，我们可以避免仅仅为保护这个操作在外围加上性能昂贵的锁，甚至借助于原子操作，我们可以实现互斥锁。 很多操作系统都为int类型提供了+-赋值的原子操作版本，比如 NT 提供了 InterlockedExchange 等API， Linux/UNIX也提供了atomic_set 等函数。 

关于java中的原子性？ 
原子性可以应用于除long和double之外的所有基本类型之上的“简单操作”。对于读取和写入出long double之外的基本类型变量这样的操作，可以保证它们会被当作不可分（原子）的操作来操作。 因为JVM的版本和其它的问题，其它的很多操作就不好说了，比如说++操作在C++中是原子操作，但在Java中就不好说了。 另外，Java提供了AtomicInteger等原子类。再就是用原子性来控制并发比较麻烦，也容易出问题。 

volatile原理是什么? 
Java中volatile关键字原义是“不稳定、变化”的意思 
使用volatile和不使用volatile的区别在于JVM内存主存和线程工作内存的同步之上。volatile保证变量在线程工作内存和主存之间一致。 
其实是告诉处理器, 不要将我放入工作内存, 请直接在主存操作我. 

接下来是测试 ：(通过测试能更好的发现和分析问题) 
申明了几种整形的变量，开启100个线程同时对这些变量进行++操作，发现结果差异很大： 
>>Execute End: 
>>Atomic: 100000 
>>VInteger: 38790 
>>Integer: 68749 
>>Source i: 99205 
>>Source Vi: 99286 
也就是说除了Atomic，其他的都是错误的。 

我们通过一些疑问，来解释一下。 

1：为什么会产生错误的数据？ 
多线程引起的，因为对于多线程同时操作一个整型变量在大并发操作的情况下无法做到同步，而Atom提供了很多针对此类线程安全问题的解决方案，因此解决了同时读写操作的问题。

2：为什么会造成同步问题？ 
Java多线程在对变量进行操作的时候，实际上是每个线程会单独分配一个针对i值的拷贝(独立内存区域)，但是申明的i值确是在主内存区域中，当对i值修改完毕后，线程会将自己内存区域块中的i值拷贝到主内存区域中，因此有可能每个线程拿到的i值是不一样的，从而出现了同步问题。

3：为什么使用volatile修饰integer变量后，还是不行？ 
因为volatile仅仅只是解决了存储的问题，即i值只是保留在了一个内存区域中，但是i++这个操作，涉及到获取i值、修改i值、存储i值(i=i+1)，这里的volatile只是解决了存储i值得问题，至于获取和修改i值，确是没有做到同步。

4：既然不能做到同步，那为什么还要用volatile这种修饰符？ 
主要的一个原因是方便，因为只需添加一个修饰符即可，而无需做对象加锁、解锁这么麻烦的操作。但是本人不推荐使用这种机制，因为比较容易出问题(脏数据)，而且也保证不了同步。

5：那到底如何解决这样的问题？ 
        第一种：采用同步synchronized解决，这样虽然解决了问题，但是也降低了系统的性能。 
        第二种：采用原子性数据Atomic变量，这是从JDK1.5开始才存在的针对原子性的解决方案，这种方案也是目前比较好的解决方案了。

6：Atomic的实现基本原理？ 
首先Atomic中的变量是申明为了volatile变量的，这样就保证的变量的存储和读取是一致的，都是来自同一个内存块，然后Atomic提供了getAndIncrement方法，该方法对变量的++操作进行了封装，并提供了compareAndSet方法，来完成对单个变量的加锁和解锁操作，方法中用到了一个UnSafe的对象，现在还不知道这个UnSafe的工作原理(似乎没有公开源代码)。Atomic虽然解决了同步的问题，但是性能上面还是会有所损失，不过影响不大，网上有针对这方面的测试，大概50million的操作对比是250ms : 850ms，对于大部分的高性能应用，应该还是够的了。

[java] view plain copy

print?

1. package qflag.ucstar.test.thread;     
2.     
3. import java.util.concurrent.atomic.AtomicInteger;      
4.      
5. /**  
6. * 测试原子性的同步  
7. * @author sigangjun 2015-3-14  
8. *  
9. */     
10. public class TestAtomic {      
11.           
12.     public static AtomicInteger astom_i = new AtomicInteger();      
13.           
14.     public static volatile Integer v_integer_i = 0;      
15.           
16.     public static volatile int v_i = 0;      
17.           
18.     public static Integer integer_i = 0;      
19.           
20.     public static int i = 0;      
21.           
22.     public static int endThread = 0;      
23.           
24.     public static void main(String[] args) {      
25.         new TestAtomic().testAtomic();      
26.      }      
27.           
28.     public void testAtomic() {      
29.               
30.         for(int i=0; i<100; i++) {      
31.             new Thread(new IntegerTestThread()).start();      
32.          }      
33.               
34.         try {      
35.             for(;;) {      
36.                  Thread.sleep(500);      
37.                 if(TestAtomic.endThread == 100) {      
38.                      System.out.println(">>Execute End:");      
39.                      System.out.println(">>Atomic: /t"+TestAtomic.astom_i);      
40.                      System.out.println(">>VInteger: /t"+TestAtomic.v_integer_i);      
41.                      System.out.println(">>Integer: /t"+TestAtomic.integer_i);      
42.                      System.out.println(">>Source i: /t"+TestAtomic.i);      
43.                      System.out.println(">>Source Vi: /t"+TestAtomic.v_i);      
44.                     break;      
45.                  }      
46.              }      
47.                   
48.          } catch (Exception e) {      
49.              e.printStackTrace();      
50.          }      
51.      }      
52.           
53. }      
54. class IntegerTestThread implements Runnable {      
55.     public void run() {      
56.         int x = 0;      
57.         while(x<1000) {      
58.              TestAtomic.astom_i.incrementAndGet();      
59.              TestAtomic.v_integer_i++;      
60.              TestAtomic.integer_i++;      
61.              TestAtomic.i++;      
62.              TestAtomic.v_i++;      
63.              x++;      
64.          }      
65.          ++TestAtomic.endThread;    //貌似很无敌！难道是原子性的吗？   
66.      }      
67. }  

-----------------------------------------xx-----------------------------------xx-----------------------------------------------

 

 

本人继续补充：

除了TestAtomic.endThread，其他的变量都被忽略了。具体解释可参见注释。

[java] view plain copy

print?

1. import java.util.concurrent.atomic.AtomicInteger;   
2. import java.io.*;  
3.   
4. /**  
5. * 测试原子性的同步  
6. * @author sigangjun 2015-3-29  
7. *  
8. */   
9. public class TestAtomic {      
10.     public static final int N=10;  
11.     public static final int M=10000;  
12.     public static int perfect_result=M*N;  
13.     public static int endThread = 0;   
14.       
15. private PrintWriter out;//将信息输入至文本"out.txt"，因为控制台buffer可能不够.  
16. public TestAtomic() throws IOException  
17. {  
18.    out =new PrintWriter(  
19.      new BufferedWriter(  
20.        new FileWriter("out.txt")));  
21. }   
22.          
23.     public static void main(String[] args) {   
24.          try{   
25.          new TestAtomic().testAtomic();   
26.          }catch(Exception e){  
27.          System.out.println(e.getMessage());  
28.           }  
29.          System.out.println("OK./nStatistical report:");  
30.          System.out.println("Covered by "+(perfect_result-endThread)+" times.");  
31.     }     
32.          
33.     public void testAtomic() {   
34.         Thread[] td=new Thread[N];  
35.         for(int i=0; i<N; i++) {     
36.         td[i]=new Thread(new IntegerTestThread(i+1));  
37.         }     
38.         for(int i=0; i<N; i++) {     
39.         td[i].start();  
40.         out.println((i+1)+" go..") ; //此处如果run()方法代码少，立即可观察到complete完成信息。  
41.         }       
42.         try {   
43.         long temp=0; //存放了上次的endTread值。  
44.         int count=1000; //如果temp值超过一千次的重复就可以认为结束程序。  
45.         for(;;) {   
46.            //Thread.sleep(1); //有可能main线程运行过快，可以调节采样的频率。  
47.            if(TestAtomic.endThread == perfect_result) {     
48.             out.println("==============/r/nPerfect!/r/n=============="); //完美匹配！  
49.                 break;   
50.             }  
51.             if(temp==TestAtomic.endThread){  
52.                out.println("Equal!!");//有重复，有可能是所有线程运行结束时的重复，也有可能是main线程采样过快。  
53.                count--;//倒计时中。。。  
54.             }  
55.             else {  
56.                temp=TestAtomic.endThread;//给temp赋新值。  
57.                count=1000;//重新设置倒计时。  
58.             }  
59.             out.println("endThread = "+TestAtomic.endThread);//在此处有几率可观察当前的endThread值比上次要少。  
60.             //这是关键之处！  
61.             if(count<=0)  
62.             {  
63.                out.println("/r/nI'll be crazy if I wait for that once again!/r/nFailed， OMG！+_+");  
64.                break;  
65.             }  
66.         }     
67.         out.close();       
68.         }catch(Exception e) {     
69.             e.printStackTrace();     
70.         }     
71.     }     
72.       
73.     class IntegerTestThread implements Runnable {   
74.     private int id;  
75.     public IntegerTestThread(int i){  
76.        this.id=i;  
77.     }  
78.     public void run() {     
79.        int i=M;//充分保证线程重叠运行  
80.        while(i>0){  
81.         try{  
82.          //Thread.sleep((int)(10*Math.random()));//设置睡眠时间，从而尽可能使线程重叠运行。  
83.         }catch(Exception e){  
84.         ++TestAtomic.endThread;//测试该语句的“原子”性。其实做完实验，我们知道，++i，i++，   i=i+1一样都不能保证原子性。  
85.         //我们可以从最终的endThread值是不是等于M*N得知。  
86.         i--;  
87.        }     
88.        out.println("************/r/n"+id+" has Completed!/r/n************/r/n") ;  
89.     }     
90.     }   
91. }