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(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为例介绍以下他们的方法:

  1. int addAndGet(int i, int delta):以原子的方式将输入值与数组中索引i的元素相加。
  2. 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 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 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多线程 原子操作类详细_第1张图片

AtomicMarkableReference 示例

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

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

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

class AtomicFiled
{

    static AtomicMarkableReference 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个类:

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

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

public class AtomicDemo {
    static AtomicReference atomicUsers = new AtomicReference<>();
    static AtomicIntegerFieldUpdater 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(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多线程 原子操作类内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

你可能感兴趣的