1class Test2 {
  2
  3    private AtomicInteger count = new AtomicInteger();
  4    public void increment() {
  5        count.incrementAndGet();
  6    }
  7    //使用AtomicInteger之后，不需要加锁，就可以实现线程安全。
  8    public int getCount() {
  9        return count.get();
 10    }
 11}
 12
 13```java
 14
 15-   多线程环境使用原子类保证线程安全
 16
 17-   AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
 18
 19### 2 数组类型
 20
 21    数组类型三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。
 22
 23```cs
 24import java.util.concurrent.atomic.AtomicIntegerArray;
 25
 26public class Demo
 27{
 28    static AtomicIntegerArray atom = new AtomicIntegerArray(a);
 29    public static void main(String[] agrs)
 30    {
 31        int[] a = {1, 2, 3, 4, 5};
 32
 33        System.out.println("原始数组：" + atom);
 34
 35        System.out.println("调用addAndGet(1, 9)方法返回值：" + atom.addAndGet(1, 9));
 36        System.out.println("调用后数组为：" + atom);
 37
 38        System.out.println("调用getAndDecrement(2)方法返回值：" + atom.getAndDecrement(2));
 39        System.out.println("调用后数组为：" + atom);
 40
 41        System.out.println("调用incrementAndGet(3)方法返回值：" + atom.incrementAndGet(3));
 42        System.out.println("调用后数组为：" + atom);
 43
 44        System.out.println("调用compareAndSet(4, 5, 100)方法返回值：" + atom.compareAndSet(4, 5, 100));
 45        System.out.println("调用后数组为：" + atom);
 46    }
 47}
 48
 49```java
 50
 51-   实现原理：简单来说还是使用sun.misc.Unsafe通过CAS操作来完成线程安全的数组操作
 52
 53-   多线程环境下需要对整形数组中的单个值执行原子更新时使用 AtomicIntegerArray。
 54
 55-   可以存放int数值的原子性数组，以整个数组对象为单位，里面的元素操作都是原子性的
 56
 57### 3 引用类型
 58
 59     **基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用引用类型原子类。**
 60
 61     引用类型三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。
 62
 63```cs
 64import java.util.concurrent.atomic.AtomicReference;
 65
 66public class AtomicReferenceTest {
 67
 68    public static void main(String[] args) {
 69        AtomicReference<Person> ar = new AtomicReference<Person>();
 70        Person person = new Person("SnailClimb", 22);
 71        ar.set(person);
 72        Person updatePerson = new Person("Daisy", 20);
 73        ar.compareAndSet(person, updatePerson);
 74
 75        System.out.println(ar.get().getName());
 76        System.out.println(ar.get().getAge());
 77    }
 78}
 79
 80class Person {
 81    private String name;
 82    private int age;
 83
 84    public Person(String name, int age) {
 85        super();
 86        this.name = name;
 87        this.age = age;
 88    }
 89
 90    public String getName() {
 91        return name;
 92    }
 93
 94    public void setName(String name) {
 95        this.name = name;
 96    }
 97
 98    public int getAge() {
 99        return age;
100    }
101
102    public void setAge(int age) {
103        this.age = age;
104    }
105
106}

 1Daisy
 220
 3
 4```java
 5
 6-   AtomicStampedReference通过一个pair来保存初始化引用和计数器，以后每次原子操作时，都需要比较引用和计数器是否都正确。
 7
 8-   AtomicMarkableReference跟AtomicStampedReference差不多，AtomicStampedReference是使用pair的int stamp作为计数器使用，AtomicMarkableReference的pair使用的是boolean mark。
 9
10> 举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初始值0，别人喝水前麻烦先做个累加才能喝水。这就是AtomicStampedReference的解决方案。还是那个水的例子，AtomicStampedReference可能关心的是动过几次，AtomicMarkableReference关心的是有没有被人动过，方法都比较简单。
11
12### 4 对象的属性修改类型
13
14     如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。
15
16     三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerFieldUpdater为例子来介绍。
17
18要想原子地更新对象的属性需要两步：
19
20**第一步**，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。
21
22**第二步**，更新的对象属性必须使用 public volatile 修饰符。
23
24```cs
25import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
26
27public class AtomicIntegerFieldUpdaterTest {
28    public static void main(String[] args) {
29        AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
30
31        User user = new User("Java", 22);
32        System.out.println(a.getAndIncrement(user));// 22
33        System.out.println(a.get(user));// 23
34    }
35}
36
37class User {
38    private String name;
39    public volatile int age;
40
41    public User(String name, int age) {
42        super();
43        this.name = name;
44        this.age = age;
45    }
46
47    public String getName() {
48        return name;
49    }
50
51    public void setName(String name) {
52        this.name = name;
53    }
54
55    public int getAge() {
56        return age;
57    }
58
59    public void setAge(int age) {
60        this.age = age;
61    }
62
63}
64
65//输出结果 
6622
6723

 1 * <p>This class is usually preferable to {@link AtomicLong} when
 2 * multiple threads update a common sum that is used for purposes such
 3 * as collecting statistics, not for fine-grained synchronization
 4 * control.  Under low update contention, the two classes have similar
 5 * characteristics. But under high contention, expected throughput of
 6 * this class is significantly higher, at the expense of higher space
 7 * consumption.
 8
 9```java
10
11> 当多个线程更新用于诸如收集统计信息而不是用于细粒度的同步控制之类的公共和时，此类通常比AtomicLong更可取。在低更新争用下，两个类具有相似的特征。但是在竞争激烈的情况下，此类的预期吞吐量会大大提高，但要消耗更多的空间。
12
13很明显LongAdder其适用于统计计数的场景，例如计算qps这种场景。在高并发场景下，qps这个值会被多个线程频繁更新的，所以LongAdder很适合。所以其更适合使用在**多线程统计计数的场景下**，在这个限定的场景下比AtomicLong要高效一些。其他低频场景下不一定能替换AtomicLong。
14
15**为什么高效？**
16
17LongAdder所使用的思想就是热点分离，这一点可以类比一下**ConcurrentHashMap**的设计思想。就是将value值分离成一个数组，当多线程访问时，通过hash算法映射到其中的一个数字进行计数。而最终的结果，就是这些数组的求和累加。这样一来，就减小了锁的粒度。如下图所示：
18
19![Image](002-35963ef5.png "image.png")
20
21**LongAccumulator**是LongAdder的功能增强版。LongAdder的API只有对数值的加减，而LongAccumulator提供了自定义的函数操作。
22
23```cs
24  // accumulatorFunction：需要执行的二元函数（接收2个long作为形参，并返回1个long）；identity：初始值
25    public LongAccumulator(LongBinaryOperator accumulatorFunction, long identity) {
26        this.function = accumulatorFunction;
27        base = this.identity = identity;
28    }
29
30```java
31
32上面构造函数，accumulatorFunction：需要执行的二元函数（接收2个long作为形参，并返回1个long）；identity：初始值。下面看一个Demo：
33
34```java
35public class LongAccumulatorDemo {
36
37    // 找出最大值
38    public static void main(String[] args) throws InterruptedException {
39        LongAccumulator accumulator = new LongAccumulator(Long::max, Long.MIN_VALUE);
40        Thread[] ts = new Thread[1000];
41
42        for (int i = 0; i < 1000; i++) {
43            ts[i] = new Thread(() -> {
44                Random random = new Random();
45                long value = random.nextLong();
46                accumulator.accumulate(value); // 比较value和上一次的比较值，然后存储较大者
47            });
48            ts[i].start();
49        }
50        for (int i = 0; i < 1000; i++) {
51            ts[i].join();
52        }
53        System.out.println(accumulator.longValue());
54    }
55}