11.Actomic原子类

1. 原子更新基本类型类

• AtomicBoolean：原子更新布尔类型
• AtomicInteger：原子更新整型
• AtomicLong：原子更新长整型

常用方法如下:

• int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger 里的 value）相加，并返回结果
• boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值
• int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值
• void lazySet（int newValue）：最终会设置成 newValue，使用 lazySet 设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值
• int getAndSet（int newValue）：以原子方式设置为 newValue 的值，并返回旧值

原子性的设置原理:通过死循环+CAS实现

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

2. 原子更新数组

通过原子的方式更新数组里的某个元素，Atomic 包提供了以下4个类。

• AtomicIntegerArray：原子更新整型数组里的元素。
• AtomicLongArray：原子更新长整型数组里的元素。
• AtomicReferenceArray：原子更新引用类型数组里的元素。
• AtomicIntegerArray 类主要是提供原子的方式更新数组里的整型

常用方法如下：

• int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。
• boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成 update 值。

public class AtomicIntegerArrayTest {
    static int[] value = new int[] { 1， 2 };
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    public static void main(String[] args) {
            ai.getAndSet(0， 3);
            System.out.println(ai.get(0));
            System.out.println(value[0]);
    }
}

3. 原子更新引用类型

• AtomicReference：原子更新引用类型。
• AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
• AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型

public class AtomicReferenceTest {
    public static AtomicReference atomicUserRef = new
        AtomicReference();
    public static void main(String[] args) {
            User user = new User("conan"， 15);
            atomicUserRef.set(user);
            User updateUser = new User("Shinichi"， 17);
            atomicUserRef.compareAndSet(user， updateUser);
            System.out.println(atomicUserRef.get().getName());
            System.out.println(atomicUserRef.get().getOld());
    }
    static class User {
            private String name;
            private int old;
            public User(String name， int old) {
                    this.name = name;
                    this.old = old;
           }
            public String getName() {
                    return name;
            }
            public int getOld() {
                    return old;
            }
    }
}

4. 原子更新字段类

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类，Atomic 包提供了以下3个类进行原子字段更新：

• AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
• AtomicLongFieldUpdater：原子更新长整型字段的更新器。
• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题

public class AtomicIntegerFieldUpdaterTest {
    // 创建原子更新器，并设置需要更新的对象类和对象的属性
    private static AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.
    newUpdater(User.class， "old");
    public static void main(String[] args) {
            // 设置柯南的年龄是10岁
            User conan = new User("conan"， 10);
            // 柯南长了一岁，但是仍然会输出旧的年龄
            System.out.println(a.getAndIncrement(conan));
            // 输出柯南现在的年龄
            System.out.println(a.get(conan));
    }
    public static class User {
            private String name;
            public volatile int old;
            public User(String name， int old) {
                    this.name = name;
                    this.old = old;
            }
            public String getName() {
                    return name;
            }
            public int getOld() {
                    return old;
            }
    }
}