devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java多线程学习（九）JUC 中的 Atomic 原子类总结

作者：你好赵伟 | 2024-08-18 05:15:19

赞

踩

juc中的atomic原子类总结
个人觉得这一节掌握基本的使用即可！

本节思维导图:

JUC 中的 Atomic 原子类总结

1 Atomic 原子类介绍

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

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic下,如下图所示。

JUC 原子类概览

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

基本类型

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

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

数组类型

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

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

引用类型

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

对象的属性修改类型

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

下面我们来详细介绍一下这些原子类。

2 基本类型原子类

2.1 基本类型原子类介绍

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

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

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

AtomicInteger 类常用方法

  1. public final int get() //获取当前的值
  2. public final int getAndSet(int newValue)//获取当前的值，并设置新的值
  3. public final int getAndIncrement()//获取当前的值，并自增
  4. public final int getAndDecrement() //获取当前的值，并自减
  5. public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
  6. boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
  7. public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
2.2 AtomicInteger 常见方法使用
  1. import java.util.concurrent.atomic.AtomicInteger;
  2.  
  3. public class AtomicIntegerTest {
  4.  
  5.     public static void main(String[] args) {
  6.         // TODO Auto-generated method stub
  7.         int temvalue = 0;
  8.         AtomicInteger i = new AtomicInteger(0);
  9.         temvalue = i.getAndSet(3);
  10.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:0;  i:3
  11.         temvalue = i.getAndIncrement();
  12.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:3;  i:4
  13.         temvalue = i.getAndAdd(5);
  14.         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:4;  i:9
  15.     }
  16.  
  17. }
2.3 基本数据类型原子类的优势

通过一个简单例子带大家看一下基本数据类型原子类的优势

①多线程环境不使用原子类保证线程安全（基本数据类型）

  1. class Test {
  2.         private volatile int count = 0;
  3.         //若要线程安全执行执行count++，需要加锁
  4.         public synchronized void increment() {
  5.                   count++; 
  6.         }
  7.  
  8.         public int getCount() {
  9.                   return count;
  10.         }
  11. }

②多线程环境使用原子类保证线程安全（基本数据类型）

  1. class Test2 {
  2.         private AtomicInteger count = new AtomicInteger();
  3.  
  4.         public void increment() {
  5.                   count.incrementAndGet();
  6.         }
  7.       //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
  8.        public int getCount() {
  9.                 return count.get();
  10.         }
  11. }
2.4 AtomicInteger 线程安全原理简单分析

AtomicInteger 类的部分源码：

  1.     // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
  2.     private static final Unsafe unsafe = Unsafe.getUnsafe();
  3.     private static final long valueOffset;
  4.  
  5.     static {
  6.         try {
  7.             valueOffset = unsafe.objectFieldOffset
  8.                 (AtomicInteger.class.getDeclaredField("value"));
  9.         } catch (Exception ex) { throw new Error(ex); }
  10.     }
  11.  
  12.     private volatile int value;

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

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

3 数组类型原子类

3.1 数组类型原子类介绍

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

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

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

AtomicIntegerArray 类常用方法

  1. public final int get(int i) //获取 index=i 位置元素的值
  2. public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
  3. public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
  4. public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
  5. public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
  6. boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
  7. public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
3.2 AtomicIntegerArray 常见方法使用
  1.  
  2. import java.util.concurrent.atomic.AtomicIntegerArray;
  3.  
  4. public class AtomicIntegerArrayTest {
  5.  
  6.     public static void main(String[] args) {
  7.         // TODO Auto-generated method stub
  8.         int temvalue = 0;
  9.         int[] nums = { 1, 2, 3, 4, 5, 6 };
  10.         AtomicIntegerArray i = new AtomicIntegerArray(nums);
  11.         for (int j = 0; j < nums.length; j++) {
  12.             System.out.println(i.get(j));
  13.         }
  14.         temvalue = i.getAndSet(0, 2);
  15.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  16.         temvalue = i.getAndIncrement(0);
  17.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  18.         temvalue = i.getAndAdd(0, 5);
  19.         System.out.println("temvalue:" + temvalue + ";  i:" + i);
  20.     }
  21.  
  22. }

4 引用类型原子类

4.1 引用类型原子类介绍

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

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

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

4.2 AtomicReference 类使用示例
  1. import java.util.concurrent.atomic.AtomicReference;
  2.  
  3. public class AtomicReferenceTest {
  4.  
  5.     public static void main(String[] args) {
  6.         AtomicReference<Person> ar = new AtomicReference<Person>();
  7.         Person person = new Person("SnailClimb", 22);
  8.         ar.set(person);
  9.         Person updatePerson = new Person("Daisy", 20);
  10.         ar.compareAndSet(person, updatePerson);
  11.  
  12.         System.out.println(ar.get().getName());
  13.         System.out.println(ar.get().getAge());
  14.     }
  15. }
  16.  
  17. class Person {
  18.     private String name;
  19.     private int age;
  20.  
  21.     public Person(String name, int age) {
  22.         super();
  23.         this.name = name;
  24.         this.age = age;
  25.     }
  26.  
  27.     public String getName() {
  28.         return name;
  29.     }
  30.  
  31.     public void setName(String name) {
  32.         this.name = name;
  33.     }
  34.  
  35.     public int getAge() {
  36.         return age;
  37.     }
  38.  
  39.     public void setAge(int age) {
  40.         this.age = age;
  41.     }
  42.  
  43. }

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

  1. Daisy
  2. 20

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

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

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

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

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

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

5.2 AtomicIntegerFieldUpdater 类使用示例
  1. import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  2.  
  3. public class AtomicIntegerFieldUpdaterTest {
  4.     public static void main(String[] args) {
  5.         AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
  6.  
  7.         User user = new User("Java", 22);
  8.         System.out.println(a.getAndIncrement(user));// 22
  9.         System.out.println(a.get(user));// 23
  10.     }
  11. }
  12.  
  13. class User {
  14.     private String name;
  15.     public volatile int age;
  16.  
  17.     public User(String name, int age) {
  18.         super();
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  22.  
  23.     public String getName() {
  24.         return name;
  25.     }
  26.  
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30.  
  31.     public int getAge() {
  32.         return age;
  33.     }
  34.  
  35.     public void setAge(int age) {
  36.         this.age = age;
  37.     }
  38.  
  39. }

输出结果：

  1. 22
  2. 23

【强烈推荐】最后，给大家推荐一下阿里云最新双11福利活动（仅限阿里云新用户购买，老用户拉新用户可以获得返现红包，后续有机会平分百万红包），优惠力度非常非常非常大，另外加入拼团，后续还有机会平分100w红包！目前我的战队已经有50多位新人了，现在是折上5折了也就是1折购买，已经达到了最低折扣！！！！！！。 划重点了： 1核2G云服务器1年仅需99.5元！！！1核2G云服务器3年仅需298.50元！！！一个月仅需8.2元 该折扣仅限新人！这是我的团队拼团地址：https://m.aliyun.com/act/team1111/#/share?params=N.FF7yxCciiM.hf47liqn ！

另外，老用户可以加入我的战队帮忙拉新，拉新你可以获得什么福利呢？①即时红包，即拆即用（最低红包10元，最高1111元）；②瓜分百万红包的机会（目前我的战队已经有29位新人，所以冲进前100的可能性非常大！冲进之后即可瓜分百万红包！）③返现奖励，如果你邀请了新人你会获得返现奖励，返现奖励直接到你的账户！（我希望我的团队最后能够冲进前100，别的不多说！！！诚信！）

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号