AtomicInteger保证线程安全的全局变量

现有业务场景需要做一个线程间的全局变量，并且实现自增效果。

  初始使用了volatile 来保证count的安全性，如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TestThredd {

    private volatile int count = 0;  
       
    public void increment() {  
        count++;  
    }  
      
    private int getCount() {  
        return count;  
    }  
      
    /** 
     * 这里模拟一个递增的任务，递增目标为50000 
     */  
    public static void main(String[] args) throws InterruptedException {  
         final TestThredd counter = new TestThredd();  
        int workCount = 50000;  
        ExecutorService executor = Executors.newFixedThreadPool(10);  
        long start = System.currentTimeMillis();  
        for (int i = 0; i < workCount; i++) {  
            Runnable runnable = new Runnable() {  
                @Override  
                public void run() {  
                    counter.increment();  
                }  
            };  
            executor.execute(runnable);  
        }  
        // 关闭启动线程，执行未完成的任务  
        executor.shutdown();  
        // 等待所有线程完成任务，完成后才继续执行下一步  
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);  
        System.out.println("耗时：" + (System.currentTimeMillis() - start) + "ms");  
        System.out.println("执行结果：count=" + counter.getCount());  
    } 
}

执行结果

它的结果不是我们预料的50000 .通常我们需要加上在count++时 加上synchronized关键字，保证他的正确性。

如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TestThredd {

    private volatile int count = 0;  
      
    /** 
     * 为了保证数据的准确性，多线程的情况下需要加上synchronized关键字
     * 否则会出现出乎预料的结果 这也是线程安全的重要体现 
     */  
    public synchronized void increment() {  
        count++;  
    }  
      
    private int getCount() {  
        return count;  
    }  
      
    /** 
     * 这里模拟一个递增的任务，递增目标为50000 
     */  
    public static void main(String[] args) throws InterruptedException {  
        final TestThredd counter = new TestThredd();  
        int workCount = 50000;  
        ExecutorService executor = Executors.newFixedThreadPool(10);  
        long start = System.currentTimeMillis();  
        for (int i = 0; i < workCount; i++) {  
            Runnable runnable = new Runnable() {  
                @Override  
                public void run() {  
                    counter.increment();  
                }  
            };  
            executor.execute(runnable);  
        }  
        // 关闭启动线程，执行未完成的任务  
        executor.shutdown();  
        // 等待所有线程完成任务，完成后才继续执行下一步  
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);  
        System.out.println("耗时：" + (System.currentTimeMillis() - start) + "ms");  
        System.out.println("执行结果：count=" + counter.getCount());  
    } 
}

为了保证数据的准确性，多线程的情况下需要加上synchronized关键字，否则会出现不安全的操作

如果我们换个方式，用AtomicInteger来替换count++，怎么做呢？

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {

     private AtomicInteger count = new AtomicInteger(0);  
     
        // 使用AtomicInteger之后，不需要加锁，也可以实现线程安全。  
        public void increment() {  
            //获取当前的值并自增  
            count.incrementAndGet();  
        }  
        /** 
         * 获取当前的值 
         * @return 
         */  
        public int getCount() {  
            return count.get();  
        }  
        //递减  
        public void deIncrement(){  
            count.decrementAndGet();  
        }  
        
        
        /** 
         * 这里模拟一个递增的任务，递增目标为50000 
         */  
        public static void main(String[] args) throws InterruptedException {  
            final AtomicCounter counter = new AtomicCounter();  
            int workCount = 50000;  
            ExecutorService executor = Executors.newFixedThreadPool(10);  
            long start = System.currentTimeMillis();  
            for (int i = 0; i < workCount; i++) {  
                Runnable runnable = new Runnable() {  
                    @Override  
                    public void run() {  
                        counter.increment();  
                    }  
                };  
                executor.execute(runnable);  
            }  
            // 关闭启动线程，执行未完成的任务  
            executor.shutdown();  
            // 等待所有线程完成任务，完成后才继续执行下一步  
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);  
            System.out.println("耗时：" + (System.currentTimeMillis() - start) + "ms");  
            System.out.println("执行结果：count=" + counter.getCount());  
        } 
}

AtomicInteger很轻松的实现了线程安全的变量操作

Java从JDK 1.5开始提供了java.util.concurrent.atomic包（以下简称Atomic包），这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性（字段）。Atomic包里的类基本都是使用Unsafe实现的包装类。

使用原子的方式更新基本类型，Atomic包提供了以下3个类。
AtomicBoolean：原子更新布尔类型。
AtomicInteger：原子更新整型。
AtomicLong：原子更新长整型。

通过原子的方式更新数组里的某个元素，Atomic包提供了以3类
AtomicIntegerArray：原子更新整型数组里的元素。
AtomicLongArray：原子更新长整型数组里的元素。
AtomicReferenceArray：原子更新引用类型数组里的元素。

 AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

AtomicInteger是在使用非阻塞算法实现并发控制，在一些高并发程序中非常适合，但并不能每一种场景都适合，不同场景要使用使用不同的数值类。

这是由硬件提供原子操作指令实现的，这里面用到了一种并发技术：CAS。在非激烈竞争的情况下，开销更小，速度更快。

参考：

http://blog.csdn.net/sunxianghuang/article/details/52277370

http://blog.csdn.net/u012734441/article/details/51619751

http://blog.csdn.net/jan_s/article/details/47025095