Java中的原子操作类

Java从JDK 1.5开始提供了java.util.concurrent.atomic包，这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式.Atomic包里的类基本都是使用Unsafe实现的包装类

1.原子更新基本类型类

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

以AtomicInteger为例：

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

/**
 * 原子操作类
 *
 * @author alu4r
 **/
public class AtomicIntegerTest {
    static AtomicInteger ai = new AtomicInteger(1);

    public static void main(String[] args) {
        System.out.println(ai.getAndIncrement());
        System.out.println(ai.get());
    }
}

2.原子更新数组

• AtomicIntegerArray：原子更新整型数组里的元素
• AtomicLongArray：原子更新长整型数组里的元素
• AtomicReferenceArray：原子更新引用类型数组里的元素

/**
 * 原子更新数组
 * 注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组 复制一份，
 * 所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组
 *
 * @author alu4r
 **/
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.原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需 要使用这个原子更新引用类型提供的类

• AtomicReference：原子更新引用类型
• AtomicReferenceFieldUpdater：原子更新引用类型里的字段
• AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类 型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，boolean initialMark）

/**
 * 原子更新引用类型
 *
 * @author alu4r
 **/
public class AtomicReferenceTest {
    public static AtomicReference<User> atomicUserRef = new AtomicReference<>();

    public static void main(String[] args) {
        User user = new User("user", 15);
        atomicUserRef.set(user);
        User updateUser = new User("updateUser", 17);
        atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(atomicUserRef.get().getName());
        System.out.println(atomicUserRef.get().getOld());
    }

    static class User {
        private final String name;
        private final 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.原子更新字段类

• AtomicIntegerFieldUpdater：原子更新整型的字段的更新器
• AtomicLongFieldUpdater：原子更新长整型字段的更新器。
• AtomicStampedReference：原子更新带有版本号的引用类型

要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新类的字段（属性）必须使用public volatile修饰符

/**
 * 原子更新字段
 *
 * @author alu4r
 **/
public class AtomicIntegerFieldUpdaterTest {
    /**
     * 创建原子更新器,并设置需要更新的对象类和对象的属性
     */
    private static final AtomicIntegerFieldUpdater<User> ATOMIC = AtomicIntegerFieldUpdater
            .newUpdater(User.class, "old");

    public static void main(String[] args) {
        // 设置柯南的年龄是10岁
        User conan = new User("conan", 10);
        // 柯南长了一岁,但是仍然会输出旧的年龄
        System.out.println(ATOMIC.getAndIncrement(conan));
        // 输出柯南现在的年龄
        System.out.println(ATOMIC.get(conan));
    }

    public static class User {
        private final 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;
        }
    }
}