[Java并发与多线程]（十八）atomic包

1、什么是原子类，有什么作用？

java.util.concurrent.atomic
特点：不可分割，一个操作是不可中断的，即便是多线程的情况下也可以保证。
作用：原子类的作用和锁类似，是为了保证并发情况下的线程安全。
不过原子类相比于锁，有一定的优势：

1. 粒度更细：原子操作可以把竞争范围缩小到变量级别，这是我们可以获得的最细粒度的情况了，通常锁的粒度都要大于原子变量的粒度；
2. 效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况。

2、Atomic*基本类型原子类

2.1 AtomicInteger：原子类

1. get()：获取当前的值
2. getAndSet(int newValue)：获取当前的值，并设置新的值
3. getAndIncrement()：获取当前的值，并自增
4. getAndDecrement()：获取当前的值，并自减
5. getAndAdd(int delta)：获取当前的值，并加上预期值
6. compareAndSet(int expect, int update)：如果输入的值等于预期值，则以原子方式将该值设置为输入值(update)

public class AtomicIntegerDemo1 implements Runnable {
    private static final AtomicInteger atomicInteger = new AtomicInteger();

    private void incrementAtomic() {
        //如果我们仅仅是对某一个数值需要保证线程安全的话，使用atomicInteger是非常合适的
        atomicInteger.getAndIncrement();
    }

    private void decrementAtomic() {
        atomicInteger.getAndDecrement();
    }

    private void getAndAdd() {
        atomicInteger.getAndAdd(10);
    }

    private static volatile int basicCount = 0;

    private synchronized void incrementBasic() {
        basicCount++;
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("原子类的结果：" + atomicInteger.get());
        System.out.println("普通变量的结果：" + basicCount);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //incrementAtomic();
            //decrementAtomic();
            getAndAdd();
            incrementBasic();
        }
    }
}

3、Atomic*Array数组类型原子类

如果说在做账务系统或者财务管理的时候，经常会有并发的修改，这种修改需要保证原子性，可以利用AtomicIntegerArray来保障线程安全。

public class AtomicArrayDemo {
    public static void main(String[] args) {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);

        Incrementer incrementer = new Incrementer(atomicIntegerArray);
        Decrementr decrementr = new Decrementr(atomicIntegerArray);

        Thread[] threadsIncrementer = new Thread[100];
        Thread[] threadsDecrementer = new Thread[100];

        for (int i = 0; i < 100; i++) {
            threadsDecrementer[i] = new Thread(decrementr);
            threadsIncrementer[i] = new Thread(incrementer);
            threadsDecrementer[i].start();
            threadsIncrementer[i].start();
        }

        //Thread.sleep(10000);
        for (int i = 0; i < 100; i++) {
            try {
                threadsDecrementer[i].join();
                threadsIncrementer[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            System.out.println(atomicIntegerArray.get(i));
            if (atomicIntegerArray.get(i) != 0) {
                System.out.println("发现了错误" + i);
            }
        }
        System.out.println("运行结束");

    }

}

class Decrementr implements Runnable {

    private AtomicIntegerArray array;

    public Decrementr(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndDecrement(i); //自减
        }
    }
}


class Incrementer implements Runnable {

    private AtomicIntegerArray array;

    public Incrementer(AtomicIntegerArray array) {
        this.array = array;
    }

    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndIncrement(i); //自增
        }
    }
}

4、Atomic*Reference引用类型原子类

AtomicReference：AtomicReference类的作用，与AtomicInteger并没有本质区别。AtomicInteger可以让一个整数保证原子性，而AtomicReference可以让一个对象保证原子性，当然，AtomicReference的功能明显比AtomicInteger强，因为一个对象里可以包含很多属性。用法和AtomicInteger类似。

public class SpinLock {
    private AtomicReference<Thread> sign = new AtomicReference<>();

    //锁住
    public void lock() {
        //拿到当前线程的引用
        Thread current = Thread.currentThread();

        //死循环，直到原子引用被赋为当前线程才会停止
        while (!sign.compareAndSet(null, current)) { //加锁
            System.out.println("自旋获取失败，再次尝试");
        }
    }

    //解锁
    public void unlock() {
        Thread current = Thread.currentThread();
        //把当前线程置为null就代表没有任何人持有这把锁——解锁
        sign.compareAndSet(current, null);
    }

    public static void main(String[] args) {
        SpinLock spinLock = new SpinLock();
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始尝试获取自旋锁");
                spinLock.lock();
                System.out.println(Thread.currentThread().getName() + "获取到了自旋锁");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {

                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + "释放了自旋锁");

                }
            }
        };

        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        thread2.start();
    }
}

5、把普通变量升级为原子类，用AtomicIntegerFieldUpdater升级原有变量

AtomicIntegerFieldUpdaterDemo.java
AtomicIntegerFieldUpdater对普通变量进行升级，适用场景：

1. 如果一个类不是我们编写的，我们没有权利去修改它，此时可以使用AtomicIntegerFieldUpdater;
2. 偶尔需要一个原子get-set操作；

AtomicIntegerFieldUpdater注意点：
a、 所能修改的是具有一个可见范围的；
b、不支持被static修饰的变量。

6、Adder累加器(*)

java8中引入的；高并发下LongAdder比AtomicLong效率高，不过本质是空间换时间；最大的好处就是在竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性；

6.1、代码演示

这里演示多线程的情况下，AtomicLong的性能，有20个线程同时对一个AtomicLong累加；由于竞争很激烈，每一次加法，都要flush和refresh，导致很耗费资源。

public class AtomicLongDemo {
    public static void main(String[] args) throws InterruptedException {
        AtomicLong counter = new AtomicLong(0);

        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            //提交任务
            service.submit(new Task(counter));
        }

        service.shutdown();
        //service.isTerminated() 判断线程池是否把任务都执行完毕
        while (!service.isTerminated()) {

        }
        long end = System.currentTimeMillis();
        System.out.println(counter.get());
        System.out.println("AtomicLong耗时：" + (end - start));
    }

    private static class Task implements Runnable {

        //成员变量
        private AtomicLong counter;

        public Task(AtomicLong counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                //循环1w次，自增
                counter.incrementAndGet();
            }
        }
    }

}

运行结果：

100000000
AtomicLong耗时：1897

public class LongAdderDemo {
    public static void main(String[] args) throws InterruptedException {
        LongAdder counter = new LongAdder();

        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            //提交任务
            service.submit(new Task(counter));
        }

        service.shutdown();
        //service.isTerminated() 判断线程池是否把任务都执行完毕
        while (!service.isTerminated()) {

        }
        long end = System.currentTimeMillis();
        System.out.println(counter.sum());
        System.out.println("LongAdder耗时：" + (end - start));
    }

    private static class Task implements Runnable {

        //成员变量
        private LongAdder counter;

        public Task(LongAdder counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                //循环1w次，自增
                counter.increment();
            }
        }
    }
}

运行结果：

100000000
LongAdder耗时：205

6.2、LongAdder带来的改进和原理

1. 在内部，这个LongAdder的实现原理和刚才的AtomicLong是有不同的，刚才的AtomicLong的实现原理是：每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率；而LongAdder不需要在每一次计算的时候都同步，而是说只有在最后求和的时候才需要把最后整个的值进行汇总。
2. 而此时的LongAdder，每个线程会有自己的一个计数器，仅用来在自己线程内计数，这样一来就不会和其他线程的计数器干扰；
3. 如图中所示，第一个线程的计数器数值也就是ctr‘，为1的时候，可能线程2的计数器ctr’‘已经是3了，它们之间并不存在竞争关系，所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和refresh。这里也没有一个公共的counter来给所有线程统一计数。
4. LongAdder引入了分段累加的概念，内部有一个base变量和一个Cell[]数组共同参与计数：
   a、base变量：竞争不激烈，直接累加到该变量上
   b、Cell[]数组：竞争激烈，各个线程分散累加自己的槽Cell[i]中
   c、sum源码分析

6.3、对比AtomicLong和LongAdder

在低争用下，AtomicLong和LongAdder这两个类具有相似的特征。但是在竞争激烈的情况下，LongAdder的预期吞吐量要高得多，但要消耗更多的空间。LongAdder适合的场景是统计求和的场景，而且LongAdder基本只提供了add方法，而AtomicLong还具有cas方法；

7、Accumulator累加器

Accumulator和Adder非常相似，Accumulator就是一个更通用版本的Adder。

public class LongAccumulatorDemo {
    public static void main(String[] args) {
        // 计算初始值和下一个值
        /*LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);
        accumulator.accumulate(1);
        System.out.println(accumulator.getThenReset());*/


        //1、计算1+2+3...+9
        /*LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);

        ExecutorService executor = Executors.newFixedThreadPool(8);

        //实现1-9，每一次提交一个计算
        IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
        executor.shutdown();
        while (!executor.isTerminated()) {

        }
        System.out.println(accumulator.getThenReset());*/


        //2、计算最大值
        LongAccumulator accumulator = new LongAccumulator((x, y) -> Math.max(x, y), 0);

        ExecutorService executor = Executors.newFixedThreadPool(8);

        //实现1-9，每一次提交一个计算
        IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
        executor.shutdown();
        while (!executor.isTerminated()) {

        }
        System.out.println(accumulator.getThenReset());

    }
}

适用场景：

1. 适合于需要大量计算并且需要并行计算的场景，如果不需要并行计算使用for循环确实可以解决问题；
   但是使用了Accumulator之后可以利用多核同时计算，大大提高计算效率；
2. 计算的顺序不能有要求，线程1可能在线程5之后执行也可能之前执行。

下一章： 第十九章 CAS原理