全面了解 Java 原子变量类

时间  2021-08-14
标签 html java git github 编程 数组 缓存 安全 markdown 多线程 栏目 Java 繁體版
原文   原文链接

📦 本文以及示例源码已归档在 javacorehtml

1、原子变量类简介

为什么须要原子变量类

保证线程安全是 Java 并发编程必需要解决的重要问题。Java 从原子性、可见性、有序性这三大特性入手，确保多线程的数据一致性。java

  • 确保线程安全最多见的作法是利用锁机制（Lock、sychronized）来对共享数据作互斥同步，这样在同一个时刻，只有一个线程能够执行某个方法或者某个代码块，那么操做必然是原子性的，线程安全的。互斥同步最主要的问题是线程阻塞和唤醒所带来的性能问题。
  • volatile 是轻量级的锁（天然比普通锁性能要好），它保证了共享变量在多线程中的可见性，但没法保证原子性。因此，它只能在一些特定场景下使用。
  • 为了兼顾原子性以及锁带来的性能问题，Java 引入了 CAS （主要体如今 Unsafe 类）来实现非阻塞同步（也叫乐观锁）。并基于 CAS ，提供了一套原子工具类。

原子变量类的做用

原子变量类 比锁的粒度更细，更轻量级，而且对于在多处理器系统上实现高性能的并发代码来讲是很是关键的。原子变量将发生竞争的范围缩小到单个变量上。git

原子变量类至关于一种泛化的 volatile 变量，可以支持原子的、有条件的读/改/写操做。github

原子类在内部使用 CAS 指令（基于硬件的支持）来实现同步。这些指令一般比锁更快。编程

原子变量类能够分为 4 组：数组

  • 基本类型
    • AtomicBoolean - 布尔类型原子类
    • AtomicInteger - 整型原子类
    • AtomicLong - 长整型原子类
  • 引用类型
    • AtomicReference - 引用类型原子类
    • AtomicMarkableReference - 带有标记位的引用类型原子类
    • AtomicStampedReference - 带有版本号的引用类型原子类
  • 数组类型
    • AtomicIntegerArray - 整形数组原子类
    • AtomicLongArray - 长整型数组原子类
    • AtomicReferenceArray - 引用类型数组原子类
  • 属性更新器类型
    • AtomicIntegerFieldUpdater - 整型字段的原子更新器。
    • AtomicLongFieldUpdater - 长整型字段的原子更新器。
    • AtomicReferenceFieldUpdater - 原子更新引用类型里的字段。

      这里不对 CAS、volatile、互斥同步作深刻探讨。若是想了解更多细节，不妨参考：Java 并发核心机制缓存

2、基本类型

这一类型的原子类是针对 Java 基本类型进行操做。安全

  • AtomicBoolean - 布尔类型原子类
  • AtomicInteger - 整型原子类
  • AtomicLong - 长整型原子类

以上类都支持 CAS，此外，AtomicInteger、AtomicLong 还支持算术运算。markdown

提示：多线程

虽然 Java 只提供了 AtomicBoolean 、AtomicInteger、AtomicLong，可是能够模拟其余基本类型的原子变量。要想模拟其余基本类型的原子变量，能够将 short 或 byte 等类型与 int 类型进行转换，以及使用 Float.floatToIntBits 、Double.doubleToLongBits 来转换浮点数。

因为 AtomicBoolean、AtomicInteger、AtomicLong 实现方式、使用方式都相近，因此本文仅针对 AtomicInteger 进行介绍。

AtomicInteger 用法

public final int get() // 获取当前值
public final int getAndSet(int newValue) // 获取当前值，并设置新值
public final int getAndIncrement()// 获取当前值，并自增
public final int getAndDecrement() // 获取当前值，并自减
public final int getAndAdd(int delta) // 获取当前值，并加上预期值
boolean compareAndSet(int expect, int update) // 若是输入值（update）等于预期值，将该值设置为输入值
public final void lazySet(int newValue) // 最终设置为 newValue，使用 lazySet 设置以后可能致使其余线程在以后的一小段时间内仍是能够读到旧的值。复制代码

AtomicInteger 使用示例：

public class AtomicIntegerDemo {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        AtomicInteger count = new AtomicInteger(0);
        for (int i = 0; i < 1000; i++) {
            executorService.submit((Runnable) () -> {
                System.out.println(Thread.currentThread().getName() + " count=" + count.get());
                count.incrementAndGet();
            });
        }

        executorService.shutdown();
        executorService.awaitTermination(30, TimeUnit.SECONDS);
        System.out.println("Final Count is : " + count.get());
    }
}复制代码

AtomicInteger 实现

阅读 AtomicInteger 源码，能够看到以下定义：

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;复制代码

说明：

- value - value 属性使用 volatile 修饰，使得对 value 的修改在并发环境下对全部线程可见。

- valueOffset - value 属性的偏移量，经过这个偏移量能够快速定位到 value 字段，这个是实现 AtomicInteger 的关键。

- unsafe - Unsafe 类型的属性，它为 AtomicInteger 提供了 CAS 操做。

3、引用类型

Java 数据类型分为 基本数据类型 和 引用数据类型 两大类（不了解 Java 数据类型划分能够参考： Java 基本数据类型 ）。

上一节中提到了针对基本数据类型的原子类，那么若是想针对引用类型作原子操做怎么办？Java 也提供了相关的原子类：

  • AtomicReference - 引用类型原子类
  • AtomicMarkableReference - 带有标记位的引用类型原子类
  • AtomicStampedReference - 带有版本号的引用类型原子类

AtomicStampedReference 类在引用类型原子类中，完全地解决了 ABA 问题，其它的 CAS 能力与另外两个类相近，因此最具表明性。所以，本节只针对 AtomicStampedReference 进行说明。

示例：基于 AtomicReference 实现一个简单的自旋锁

public class AtomicReferenceDemo2 {

    private static int ticket = 10;

    public static void main(String[] args) {
        threadSafeDemo();
    }

    private static void threadSafeDemo() {
        SpinLock lock = new SpinLock();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread(lock));
        }
        executorService.shutdown();
    }

    /**
     * 基于 {@link AtomicReference} 实现的简单自旋锁
     */
    static class SpinLock {

        private AtomicReference<Thread> atomicReference = new AtomicReference<>();

        public void lock() {
            Thread current = Thread.currentThread();
            while (!atomicReference.compareAndSet(null, current)) {}
        }

        public void unlock() {
            Thread current = Thread.currentThread();
            atomicReference.compareAndSet(current, null);
        }

    }

    /**
     * 利用自旋锁 {@link SpinLock} 并发处理数据
     */
    static class MyThread implements Runnable {

        private SpinLock lock;

        public MyThread(SpinLock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while (ticket > 0) {
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                    ticket--;
                }
                lock.unlock();
            }
        }

    }

}复制代码

原子类的实现基于 CAS 机制，而 CAS 存在 ABA 问题（不了解 ABA 问题，能够参考：Java 并发基础机制 - CAS 的问题）。正是为了解决 ABA 问题，才有了 AtomicMarkableReference 和 AtomicStampedReference。

AtomicMarkableReference 使用一个布尔值做为标记，修改时在 true / false 之间切换。这种策略不能根本上解决 ABA 问题，可是能够下降 ABA 发生的概率。经常使用于缓存或者状态描述这样的场景。

public class AtomicMarkableReferenceDemo {

    private final static String INIT_TEXT = "abc";

    public static void main(String[] args) throws InterruptedException {

        final AtomicMarkableReference<String> amr = new AtomicMarkableReference<>(INIT_TEXT, false);

        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(Math.abs((int) (Math.random() * 100)));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    String name = Thread.currentThread().getName();
                    if (amr.compareAndSet(INIT_TEXT, name, amr.isMarked(), !amr.isMarked())) {
                        System.out.println(Thread.currentThread().getName() + " 修改了对象！");
                        System.out.println("新的对象为：" + amr.getReference());
                    }
                }
            });
        }

        executorService.shutdown();
        executorService.awaitTermination(3, TimeUnit.SECONDS);
    }

}复制代码

AtomicStampedReference 使用一个整型值作为版本号，每次更新前先比较版本号，若是一致，才进行修改。经过这种策略，能够根本上解决 ABA 问题。

public class AtomicStampedReferenceDemo {

    private final static String INIT_REF = "pool-1-thread-3";

    private final static AtomicStampedReference<String> asr = new AtomicStampedReference<>(INIT_REF, 0);

    public static void main(String[] args) throws InterruptedException {

        System.out.println("初始对象为：" + asr.getReference());

        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            executorService.execute(new MyThread());
        }

        executorService.shutdown();
        executorService.awaitTermination(3, TimeUnit.SECONDS);
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(Math.abs((int) (Math.random() * 100)));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            final int stamp = asr.getStamp();
            if (asr.compareAndSet(INIT_REF, Thread.currentThread().getName(), stamp, stamp + 1)) {
                System.out.println(Thread.currentThread().getName() + " 修改了对象！");
                System.out.println("新的对象为：" + asr.getReference());
            }
        }

    }

}复制代码

4、数组类型

Java 提供了如下针对数组的原子类：

  • AtomicIntegerArray - 整形数组原子类
  • AtomicLongArray - 长整型数组原子类
  • AtomicReferenceArray - 引用类型数组原子类

已经有了针对基本类型和引用类型的原子类，为何还要提供针对数组的原子类呢？

数组类型的原子类为 数组元素 提供了 volatile 类型的访问语义，这是普通数组所不具有的特性——volatile 类型的数组仅在数组引用上具备 volatile 语义。

示例：AtomicIntegerArray 使用示例（AtomicLongArray 、AtomicReferenceArray 使用方式也相似）

public class AtomicIntegerArrayDemo {

    private static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(10);

    public static void main(final String[] arguments) throws InterruptedException {

        System.out.println("Init Values: ");
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            atomicIntegerArray.set(i, i);
            System.out.print(atomicIntegerArray.get(i) + " ");
        }
        System.out.println();

        Thread t1 = new Thread(new Increment());
        Thread t2 = new Thread(new Compare());
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final Values: ");
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            System.out.print(atomicIntegerArray.get(i) + " ");
        }
        System.out.println();
    }

    static class Increment implements Runnable {

        @Override
        public void run() {

            for (int i = 0; i < atomicIntegerArray.length(); i++) {
                int value = atomicIntegerArray.incrementAndGet(i);
                System.out.println(Thread.currentThread().getName() + ", index = " + i + ", value = " + value);
            }
        }

    }

    static class Compare implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < atomicIntegerArray.length(); i++) {
                boolean swapped = atomicIntegerArray.compareAndSet(i, 2, 3);
                if (swapped) {
                    System.out.println(Thread.currentThread().getName() + " swapped, index = " + i + ", value = 3");
                }
            }
        }

    }

}复制代码

5、属性更新器类型

更新器类支持基于反射机制的更新字段值的原子操做。

  • AtomicIntegerFieldUpdater - 整型字段的原子更新器。
  • AtomicLongFieldUpdater - 长整型字段的原子更新器。
  • AtomicReferenceFieldUpdater - 原子更新引用类型里的字段。

这些类的使用有必定限制：

  • 由于对象的属性修改类型原子类都是抽象类，因此每次使用都必须使用静态方法 newUpdater() 建立一个更新器，而且须要设置想要更新的类和属性。
  • 字段必须是 volatile 类型的；
  • 不能做用于静态变量（static）；
  • 不能做用于常量（final）； 
public class AtomicReferenceFieldUpdaterDemo {

    static User user = new User("begin");

    static AtomicReferenceFieldUpdater<User, String> updater =
        AtomicReferenceFieldUpdater.newUpdater(User.class, String.class, "name");

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread());
        }
        executorService.shutdown();
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            if (updater.compareAndSet(user, "begin", "end")) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 已修改 name = " + user.getName());
            } else {
                System.out.println(Thread.currentThread().getName() + " 已被其余线程修改");
            }
        }

    }

    static class User {

        volatile String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public User setName(String name) {
            this.name = name;
            return this;
        }

    }

}复制代码

参考资料

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程