如何理解Java多线程原子操作类

发布时间：2021-10-08 09:02:57 作者：iii
来源：亿速云阅读：120

本篇内容主要讲解“如何理解Java多线程原子操作类”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“如何理解Java多线程原子操作类”吧!

1、What and Why

原子的本意是不能被分割的粒子，而对于一个操作来说，如果它是不可被中断的一个或者一组操作，那么他就是原子操作。显然，原子操作是安全的，因为它不会被打断。

平时我们见到的很多操作看起来是原子操作，但其实是非原子操作，例如很常见的i++操作，它背后有取值、加一、写回等操作，如果有两个线程都要对 i 进行加一操作，就有可能结果把i只变成了2，这就是线程不安全的更新操作，当然我们可以使用synchronized解决，但是JUC提供了java.util.concurrent.atomic包，这个包的原子操作类提供了一种简单高效、线程安全地更新一个变量的方式。

2、原子更新基本类型类

使用原子的方式更新基本类型，Atomic包提供了以下3个类：

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

上面三个类型的方法几乎一模一样，下面以AtomicInteger为例介绍以下他们的方法

int addAndGet(int data)：以原子操作的方式将输入data与AtomicInteger原有的值相加，并返回结果。
boolean compareAndSet(int expect, int update)：如果输入的数值等于预期值expect，则以原子操作的方式将update赋给AtomicInteger原有的值。
getAndIncrement()：以原子操作的方式给AtomicInteger原有的值加一，但是注意这个方法返回的值是自增前的值。
int getAndSet(int newValue)：以原子操作的方式给AtomicInteger原有的值设置成newValue的值
void lazySet(int newValue)：最终会设置成newValue，但是使用lazyset设置之后，可能会导致其他线程在之后的一小段时间内还可以读到旧值。

class AtomicIntegerDemo{

    static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {



        //新建一个线程池
        ExecutorService threadPoolExecutor = new ThreadPoolExecutor(2,
                4,
                100,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

    // 新建一个线程
    threadPoolExecutor.execute(
        () -> {
          for (int i = 0; i < 10; i++) {
              atomicInteger.incrementAndGet();
          }

        });

        //新建一个线程
        threadPoolExecutor.execute(()->{
            for (int i = 0; i < 10; i++) {
                atomicInteger.incrementAndGet();
            }
        });

        System.out.println(atomicInteger.get());
        threadPoolExecutor.shutdown();
    }
}

3、实现原理

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

其中，unsafe类是Java用来处理一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，它使得Java拥有了类似C语言一样操作内存空间的能力。

valueOffset是字段value的内存偏移地址，valueOffset的值在AtomicInteger初始化时，在静态代码块中通过Unsafe的objectFieldOffset方法获取。在AtomicInteger中提供的线程安全方法中，通过字段valueOffset的值可以定位到AtomicInteger对象中value的内存地址，从而可以根据CAS实现对value字段的原子操作。

public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }

打开getAndAddInt()函数，可以看到这里使用了一个CAS机制的自旋锁来对v值进行赋值,关于CAS机制可以查看文章Java多线程乐观锁和CAS机制
，getIntVolatile方法用于获取对象o指定偏移量的int值，此操作具有volatile内存语义，也就是说，即使对象o指定offset的变量不是volatile的，次操作也会使用volatile语义，会强制从主存获取值，然后通过compareAndSwapInt来替换值，直到替换成功后，退出循环。

4、原子更新数组

使用原子的方式更新数组中的某个元素，Atomic包提供了以下3个类：

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

下面以AtomicIntegerArray为例介绍以下他们的方法：

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

5、原子更新引用类型

刚刚提到的只能一次更新一个变量，如果要更新多个变量就需要使用原子更新引用类型提供的类了：

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

AtomicReference 示例

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

class Reference
{
    static AtomicReference<User> atomicUser = new AtomicReference<>();

    public static void main(String[] args) {

        User u = new User("1",10);
        atomicUser.set(u);
        System.out.println(atomicUser.get());
        atomicUser.compareAndSet(u,new User("2",15));
        System.out.println(atomicUser.get());
        System.out.println(atomicUser.compareAndSet(u, new User("3", 123)));
        System.out.println(atomicUser.compareAndSet(new User("2", 15), u));
    }
}

AtomicReferenceFieldUpdate

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

    public static void main(String[] args) {
        //
        User u = new User("123",10);
        System.out.println(u);

        System.out.println(nameField.compareAndSet(u, "123", "xiaohua"));
        System.out.println(u);
        System.out.println(nameField.compareAndSet(u,"123","xiaoli"));
    }
}

如何理解Java多线程原子操作类

AtomicMarkableReference 示例

前面介绍的都是在原子操作下对一个数据进行修改，AtomicMarkableReference 不同的是，它不仅可以修改，还定义了一个变量去判断是他之前是否已经被修改过了，这里就不得不提到ABA问题了：

ABA问题就是如果一个线程把变量a的值由1变成2，另一个线程又把变量a的值由2变回了1，这个时候变量a的值相当于没有变过，但实际上其实已经被更改了，这就是ABA问题。可以举一个更形象的例子，杯子里有一杯水，小明把它喝完了，之后又接满水放回原处，这时小华来了如果知道了杯子被人用过那肯定不会再喝了，如果小明喝完之后那张纸记录下已经用过，那么小华来了就知道了。AtomicMarkableReference就提供了这样一个布尔变量记录值是否被修改过。

AtomicMarkableReference初始化时需要传入一个引用值（类型就是前面填的泛型），此外还需要传入一个布尔值用作判断是否修改。AtomicMarkableReference的compareAndSet要传入两组参数：旧的引用值和新的引用值；旧的布尔值和新的布尔值，只有传入的旧引用值和旧布尔值与对象中的值相同，才会修改引用值和布尔值。

class AtomicFiled
{

    static AtomicMarkableReference<Integer> intMarkable = new AtomicMarkableReference<>(123,false);

    public static void main(String[] args) {

        System.out.println(intMarkable.getReference());
        System.out.println(intMarkable.isMarked());
        System.out.println(intMarkable.compareAndSet(123,100,false,true));
        System.out.println(intMarkable.getReference());
        System.out.println(intMarkable.isMarked());
        System.out.println(intMarkable.compareAndSet(100,123,false,true));

    }
}

6、原子更新字段类

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

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器
AtomicLongFieldUpdater：原子更新长整型的字段的更新器
AtomicStampedReference：原子更新带版本号的引用类型。使用版本号解决ABA问题

需要注意的是，原子地更新字段类需要两步：第一步需要用静态方法newUpdate()创建一个更新器，并且设置想要更新的类和属性。第二步，更新类的字段（属性）必须使用public volatile修饰符。

public class AtomicDemo {
    static AtomicReference<User> atomicUsers = new AtomicReference<>();
    static AtomicIntegerFieldUpdater<User> userAge = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
    static CountDownLatch countDownLatch = new CountDownLatch(2);

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

          User u = new User("123",0);
          atomicUsers.set(u);
          ExecutorService threadPoolExecutor = new ThreadPoolExecutor(3,
                  6,
                  100,
                  TimeUnit.MILLISECONDS,
                  new ArrayBlockingQueue<Runnable>(10),
                  Executors.defaultThreadFactory(),
                  new ThreadPoolExecutor.AbortPolicy());
          threadPoolExecutor.execute(()->
          {

              try {
                  TimeUnit.MILLISECONDS.sleep(200);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"  "+atomicUsers.get().getAge());
              userAge.incrementAndGet(u);
             countDownLatch.countDown();
          });

          threadPoolExecutor.shutdown();
          countDownLatch.await();
          System.out.println(atomicUsers.get().getAge());
  }
}

到此，相信大家对“如何理解Java多线程原子操作类”有了更深的了解，不妨来实际操作一番吧！这里是亿速云网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！

如何理解Java多线程原子操作类

目录

1、What and Why

2、原子更新基本类型类

3、实现原理

4、原子更新数组

5、原子更新引用类型

6、原子更新字段类

相关阅读