JUC 中的 Atomic 原子类总结

2019年3月10日 218次阅读 来源: JUC

继该篇博文从内存可见性看Volatile、原子变量和CAS算法后继续学习JUC中的原子类。

【1】原子类概述

Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。包java.util.concurrent.atomic下原子类如下所示：
《JUC 中的 Atomic 原子类总结》

根据操作的数据类型，可以将JUC包中的原子类分为4类。

基本类型，使用原子的方式更新基本类型

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

数组类型，使用原子的方式更新数组里的某个元素

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

引用类型

  • AtomicReference：引用类型原子类
  • AtomicStampedRerence：原子更新引用类型里的字段原子类
  • AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

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

【2】基本类型原子类

① 基本类型原子类介绍

使用原子的方式更新基本类型

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

上面三个类提供的方法几乎相同，所以我们这里以 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 常见方法使用

测试方法如下：

@Test
public void contextLoads2() {
	// TODO Auto-generated method stub
	int temvalue = 0;
	AtomicInteger i = new AtomicInteger(0);
	temvalue = i.getAndSet(3);
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:0;  i:3
	temvalue = i.getAndIncrement();
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:3;  i:4
	temvalue = i.getAndAdd(5);
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:4;  i:9
}

由此可见，getAndXxxx方法，是先获取值返回，并进行compareAndSwapInt方法更新值。以getAndIncrement()方法为例如下所示。

AtomicInteger.getAndIncrement()方法：

 public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

Unsafe.getAndAddInt方法：

  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;
    }

③ AtomicInteger 线程安全原理简单分析

原子类的优势就是线程安全。其部分源码如下所示：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    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;

    /**
     * Creates a new AtomicInteger with the given initial value.
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }
    //...
 }

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

这里不理解CAS、内存可见性的参考博文从内存可见性看Volatile、原子变量和CAS算法。

【3】数组类型原子类

① 数组类型原子类介绍

使用原子的方式更新数组里的某个元素

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

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。

AtomicIntegerArray 类常用方法

  • public final int get(int i) //获取 index=i 位置元素的值
  • public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
  • public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
  • public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
  • public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
  • boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
  • public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

② AtomicIntegerArray 常见方法使用

测试代码如下：

@Test
public void contextLoads3() {
	// TODO Auto-generated method stub
	int temvalue = 0;
	int[] nums = { 1, 2, 3, 4, 5, 6 };
	AtomicIntegerArray i = new AtomicIntegerArray(nums);
	for (int j = 0; j < nums.length; j++) {
		System.out.println(i.get(j));
	}
	temvalue = i.getAndSet(0, 2);
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue : 1 , i:{ 2, 2, 3, 4, 5, 6 }
	temvalue = i.getAndIncrement(0);
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue : 2 , i:{ 3, 2, 3, 4, 5, 6 }
	temvalue = i.getAndAdd(0, 5);
	System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue : 2 , i:{ 8, 2, 3, 4, 5, 6 }
}

【4】引用类型原子类

① 引用类型原子类介绍

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。

  • AtomicReference：引用类型原子类
  • AtomicStampedRerence：原子更新引用类型里的字段原子类
  • AtomicMarkableReference ：原子更新带有标记位的引用类型

上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。

② AtomicReference 类使用示例

测试代码如下：

public class AtomicReferenceTest {

    public static void main(String[] args) {
        AtomicReference<Person> ar = new AtomicReference<Person>();
        Person person = new Person("SnailClimb", 22);
        ar.set(person);
        Person updatePerson = new Person("Daisy", 20);
        ar.compareAndSet(person, updatePerson);

        System.out.println(ar.get().getName());
        System.out.println(ar.get().getAge());
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下：

Daisy
20

【5】对象的属性修改类型原子类

① 对象的属性修改类型原子类介绍

如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。

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

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

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerFieldUpdater为例子来介绍。

② AtomicIntegerFieldUpdater 类使用示例

测试代码如下所示：

public class AtomicIntegerFieldUpdaterTest {
    public static void main(String[] args) {
        AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

        User user = new User("Java", 22);
        System.out.println(a.getAndIncrement(user));// 22
        System.out.println(a.get(user));// 23
    }
}

class User {
    private String name;
    public volatile int age;

    public User(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

输出结果：

22
23
    原文作者：JUC
    原文地址: https://blog.csdn.net/J080624/article/details/84838991
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞