Java NIO -AtomicInteger

概述

通常情况下，在Java中我们对++i,--i的操作都是非线程安全的。对于一个++i存在三个独立的操作，获取变量i当前的值，为该值+1。如下代码，多线程操作i++。

   
   
   
   

    
    
    
    
public class UnsafeI {
    
    
    
    

    
    
    
    
 public static int num = 0;
    
    
    
    

    
    
    
    
 public static void main(String[] args) throws InterruptedException {
    
    
    
    
 final int threadSize = 10000;
    
    
    
    
 Thread[] ts = new Thread[threadSize];
    
    
    
    
 for (int i = 0; i < threadSize; i++) {
    
    
    
    
 ts[i] = new Thread() {
    
    
    
    
 public void run() {
    
    
    
    
 num++;
    
    
    
    
 }
    
    
    
    
 };
    
    
    
    
 }
    
    
    
    
 for (Thread t : ts) {
    
    
    
    
 t.start();
    
    
    
    
 }
    
    
    
    
 
    
    
    
    
 System.out.println(num);
    
    
    
    
 }
    
    
    
    
}
   
   
   
   

多次运行，在可能的情况下，我们会看到输出的num存在不同的值。

AtomicInteger提供一系列的线程安全的方法，供我们实现i++操作。

   
   
   
   

    
    
    
    
  /**
    
    
    
    
     * Atomically increments by one the current value.
    
    
    
    
     *
    
    
    
    
     * @return the previous value
    
    
    
    
     */
    
    
    
    
    public final int getAndIncrement() {
    
    
    
    
        for (;;) {
    
    
    
    
            int current = get();
    
    
    
    
            int next = current + 1;
    
    
    
    
            if (compareAndSet(current, next))
    
    
    
    
                return current;
    
    
    
    
        }
    
    
    
    
    }
   
   
   
   

   
   
   
   

    
    
    
    
    /**
    
    
    
    
     * Atomically sets the value to the given updated value
    
    
    
    
     * if the current value {@code ==} the expected value.
    
    
    
    
     *
    
    
    
    
     * @param expect the expected value
    
    
    
    
     * @param update the new value
    
    
    
    
     * @return true if successful. False return indicates that
    
    
    
    
     * the actual value was not equal to the expected value.
    
    
    
    
     */
    
    
    
    
    public final boolean compareAndSet(int expect, int update) {
    
    
    
    
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    
    
    
    
    }
   
   
   
   



底层通过Unsafe方法实现。具体Unsafe的各个防范，有兴趣的可以参考如下博客，写的比较详细： http://ifeve.com/sun-misc-unsafe/

我们多线程环境对AtomicInteger进行操作。

   
   
   
   

    
    
    
    

    
    
    
    
import java.util.concurrent.atomic.AtomicInteger;
    
    
    
    

    
    
    
    
public class SafeAtomicInteger {
    
    
    
    

    
    
    
    
  static final AtomicInteger value = new AtomicInteger(0);
    
    
    
    
  
    
    
    
    
  
    
    
    
    
  public static void main(String[] args) throws InterruptedException {
    
    
    
    
 final int threadSize = 10000;
    
    
    
    
 Thread[] ts = new Thread[threadSize];
    
    
    
    
 for (int i = 0; i < threadSize; i++) {
    
    
    
    
 ts[i] = new Thread() {
    
    
    
    
 public void run() {
    
    
    
    
 value.incrementAndGet();
    
    
    
    
 }
    
    
    
    
 };
    
    
    
    
 }
    
    
    
    
 for (Thread t : ts) {
    
    
    
    
 t.start();
    
    
    
    
 }
    
    
    
    
 
    
    
    
    
 System.out.println(value.get());
    
    
    
    
 }
    
    
    
    
}
   
   
   
   

参考列表：http://www.blogjava.net/xylz/archive/2010/07/01/324988.html

http://ifeve.com/sun-misc-unsafe/