Java使用AtomicInteger来实现原子性自增

最近工作比较忙，没啥时间写笔记，丢一个老笔记上来吧。

先放出工具类代码：

package com.example.demo;

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

/**
 * 使用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());
    }
}

在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的方式进行加减操作。

AtomicInteger：使用非阻塞算法（无锁定无等待）实现并发控制，相比Lock（阻塞算法）和synchronized实现，更加高效。AtomicInteger是在使用非阻塞算法实现并发控制，在一些高并发程序中非常适合，但并不能每一种场景都适合，不同场景要使用使用不同的数值类。

自动递增核心代码分析：

public final int incrementAndGet() {
	for (;;) {
		int current = get();
		int next = current + 1;
		if (compareAndSet(current, next)){
			return next;
		}
	}
}

通过源码，可以知道，这个方法的做法为先获取到当前的 value 属性值，然后将 value 加 1，赋值给一个局部的 next 变量，然而，这两步都是非线程安全的，但是内部有一个死循环，不断去做compareAndSet操作，直到成功为止。

类似的，还有decrementAndGet()方法。它和incrementAndGet()的区别是将 value 减 1，赋值给next 变量。

AtomicInteger中还有getAndIncrement() 和getAndDecrement() 方法，他们的实现原理和上面的两个方法完全相同，区别是返回值不同，前两个方法返回的是改变之后的值，即next。而这两个方法返回的是改变之前的值，即current。