亲宝软件园·资讯

展开

Java多线程 原子操作类 Java多线程 原子操作类详细

JavaWarriors 人气:0
想了解Java多线程 原子操作类详细的相关内容吗,JavaWarriors在本文为您仔细讲解Java多线程 原子操作类的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java多线程,原子操作类,下面大家一起来学习吧。

1、What and Why

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

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

2、原子更新基本类型类

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

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

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

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

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

5、原子更新引用类型

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

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

 

AtomicMarkableReference 示例

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

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

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

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

  1. AtomicIntegerFieldUpdater:原子更新整型的字段的更新器
  2. AtomicLongFieldUpdater:原子更新长整型的字段的更新器
  3. 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());
  }
}

加载全部内容

相关教程
猜你喜欢
用户评论