concurrent包中的Atomic类

转：http://www.iteye.com/topic/1124582
这是一个真实案例，曾经惹出硕大风波，故事的起因却很简单，就是需要实现一个简单的计数器，每次取值然后加1，于是就有了下面这段代码： 

Java代码  

private int counter = 0;  

1.        public int getCount ( ) {  
2.                 return counter++;  
3.        }  

    这个计数器被用于生成一个sessionId，这个sessionID用于和外部计费系统交互，这个sessionId理所当然的要求保证全局唯一而不重复。但是很遗憾，上面的代码最终被发现会产生相同的id，因此会造成一些请求莫名其妙的报错.....更痛苦的是，上面这段代码是一个来自其他部门开发的工具类，我们当时只是拿了它的jar包来调用，没有源码，更没有想这里面会有如此低级而可怕的错误。 

    由于重复的sessionId，造成有个别请求失败，虽然出现概率极低，经常跑一天测试都不见得能重现一次。因为是和计费相关，因此哪怕是再低的概率出错，也不得不要求解决。实际情况是，项目开发到最后阶段，都开始做发布前最后的稳定性测试了，在7*24小时的连续测试中，这个问题往往在测试开始几天后才重现，将当时负责trouble shooting的同事折腾的很惨......经过反复的查找，终于有人怀疑到这里，反编译了那个jar包，才看到上面这段出问题的代码。 

    这个低级的错误，源于一个java的基本知识： 

    ++操作，无论是i++还是++i，都不是原子操作！ 

    而一个非原子操作，在多线程并发下会有线程安全的问题：这里稍微解释一下，上面的"++"操作符，从原理上讲它其实包含以下：计算加1之后的新值，然后将这个新值赋值给原变量，返回原值。类似于下面的代码 

Java代码  

1. private int counter = 0;  
2. public int getCount ( ) {  
3.          int result = counter;  
4.          int newValue = counter + 1; // 1. 计算新值  
5.          counter = newValue;         // 2. 将新值赋值给原变量  
6.          return result;  
7. }  

    多线程并发时，如果两个线程同时调用getCount()方法，则他们可能得到相同的counter值。为了保证安全，一个最简单的方法就是在getCount()方法上做同步： 

Java代码  

1. private int counter = 0;  
2.        public synchronized int getCount ( ) {  
3.                 return counter++;  
4.        }  

    这样就可以避免因++操作符的非原子性而造成的并发危险。 

    我们在这个案例基础上稍微再扩展一下，如果这里的操作是原子操作，就可以不用同步而安全的并发访问吗？我们将这个代码稍作修改: 

Java代码  

1. private int something = 0;  
2.        public int getSomething ( ) {  
3.                 return something;  
4.        }  
5.        public void setSomething (int something) {  
6.                 this.something = something;  
7.        }  

    假设有多线程同时并发访问getSomething()和setSomething()方法，那么当一个线程通过调用setSomething()方法设置一个新的值时，其他调用getSomething()的方法是不是立即可以读到这个新值呢？这里的"this.something = something;" 是一个对int 类型的赋值，按照java 语言规范，对int的赋值是原子操作，这里不存在上面案例中的非原子操作的隐患。 

    但是这里还是有一个重要问题，称为"内存可见性"。这里涉及到java内存模型的一系列知识，限于篇幅，不详尽讲述，不清楚这些知识点的可以自己翻翻资料，最简单的办法就是google一下这两个关键词"java 内存模型", "java 内存可见性"。或者，可以参考这个帖子"java线程安全总结"， http://www.iteye.com/topic/806990。 

    解决这里的"内存可见性"问题的方式有两个，一个是继续使用 synchronized 关键字，代码如下 

Java代码  

1. private int something = 0;  
2.        public synchronized  int getSomething ( ) {  
3.                 return something;  
4.        }  
5.        public synchronized  void setSomething (int something) {  
6.                 this.something = something;  
7.        }  

     另一个是使用volatile 关键字， 

Java代码  

1. private volatile int something = 0;  
2.        public int getSomething ( ) {  
3.                 return something;  
4.        }  
5.        public void setSomething (int something) {  
6.                 this.something = something;  
7.        }  

    使用volatile 关键字的方案，在性能上要好很多，因为volatile是一个轻量级的同步，只能保证多线程的内存可见性，不能保证多线程的执行有序性。因此开销远比synchronized要小。 

    让我们再回到开始的案例，因为我们采用直接在 getCount() 方法前加synchronized 的修改方式，因此不仅仅避免了非原子性操作带来的多线程的执行有序性问题，也"顺带"解决了内存可见性问题。 

    OK，现在可以继续了，前面讲到可以通过在 getCount() 方法前加synchronized 的方式来解决问题，但是其实还有更方便的方式，可以使用jdk 5.0之后引入的concurrent包中提供的原子类，java.util.concurrent.atomic.Atomic***，如AtomicInteger，AtomicLong等。 

Java代码  

1. private AtomicInteger  counter = new AtomicInteger(0);  
2. public int getCount ( ) {  
3.      return counter.incrementAndGet();  
4. }  

    Atomic类不仅仅提供了对数据操作的线程安全保证，而且提供了一系列的语义清晰的方法如incrementAndGet(),getAndIncrement,addAndGet(),getAndAdd()，使用方便。更重要的是，Atomic类不是一个简单的同步封装，其内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile，从而避免了synchronized的高开销，执行效率大为提升。限于篇幅，关于“CAS”原理就不在这里讲诉。 

    因此，出于性能考虑，强烈建议尽量使用Atomic类，而不要去写基于synchronized关键字的代码实现。 

    最后总结一下，在这个帖子中我们讲诉了一下几个问题： 

    1. ++操作不是原子操作 
    2. 非原子操作有线程安全问题 
    3. 并发下的内存可见性 
    4. Atomic类通过CAS + volatile可以比synchronized做的更高效，推荐使用