【并发编程】原子类-阿里云开发者社区

1.什么是原子类

（1）原子类简介

一度认为原子是不可分割的最小单元，故原子类可以认为其操作都是不可分割的。

（2）为什么要有原子类

对多线程访问一个变量，我们需要加锁，而锁是比较消耗性能的，JDK1.5之后，新增的原子操作类提供了一种用法简单、性能高效、线程安全的更新一个变量的方式，这些同类位于JUC包下的atomic包下，发展到JDK1.8，该包下共有17个类，囊括了原子更新基本类型、原子更新属性、原子更新引用。

（3）JDK1.8新增的原子类

DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder、Striped64

2.原子更新基本类型

JDK1.8基本类型原子类有以下分类
AtomicBoolean：原子更新布尔类型
AtomicInteger：原子更新整型
AtomicLong：原子更新长整型
DoubleAdder：对Double的原子更新性能进行优化提升
LongAdder：对Long的原子更新性能进行优化提升

DoubleAccumulator：支持自定义运算
LongAccumulator：支持自定义运算

AtomicInteger的常见用法
AtomicInteger(int initialValue)：创建一个AtomicInteger实例，初始值由参数指定。不带参的构造方法初始值为0。
int addAndGet(int delta) ：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果，与getAndAdd(int delta)相区分，从字面意思即可区分，前者返回相加后结果，后者先返回再相加。
boolean compareAndSet(int expect, int update) ：如果当前值等于预期值，则以原子方式将该值设置为输入的值。
int getAndIncrement()：以原子方式将当前值加1，注意：这里返回的是自增前的值。
void lazySet(int newValue)：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

int getAndSet(int newValue)：以原子方式设置为newValue的值，并返回旧值。

案例实战

线程不安全的例子

public class Demo1 {
    private static Integer num = 0;
    void addUnSafe(){
        //对atomicInteger进行++操作
        num++;
    }
    public static void main(String[] args) throws InterruptedException {
        Demo1 demo1 = new Demo1();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 1000; j++) {
                    demo1.addUnSafe();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 1000; j++) {
                    demo1.addUnSafe();
                }
            }
        }).start();
        Thread.sleep(2000L);
        System.out.println("num最后的值："+num);
}

AtomicInteger多线程调用

public class Demo1 {
    private static AtomicInteger atomicInteger = new AtomicInteger(0);
    void addSafe(){
        //对atomicInteger进行++操作
        atomicInteger.incrementAndGet();
    }
    public static void main(String[] args) throws InterruptedException {
      new Thread(()->{
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 1000; j++) {
                    demo1.addSafe();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 1000; j++) {
                    demo1.addSafe();
                }
            }
        }).start();
        Thread.sleep(2000L);
        System.out.println("atomicInteger最后的值："+atomicInteger.get());   
    }
}

LongAccumulator的简单使用

public class Demo2 {
    private static LongAccumulator longAccumulator = new LongAccumulator((x,y) -> x*y,3L);
    public static void main(String[] args) {
        longAccumulator.accumulate(2);
        System.out.println(longAccumulator.get());
    }
}

3.原子更新数组类型

AtomicIntegerArray：对Integer数组类型的操作
AtomicLongArray：对Long数组类型的操作
AtomicReferenceArray：对对象数组类型的操作
AtomicIntegerArray的简单使用

public class Demo1 {
    public static void main(String[] args) {
        int[] arrInt = new int[]{2,3,4};
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(arrInt);
        //给数组下标是1的元素+2
        int i = atomicIntegerArray.addAndGet(1, 2);
        System.out.println(i);
        //支持自定义规则的操作
        int i1 = atomicIntegerArray.accumulateAndGet(1, 2, (x, y) -> x > y ? x : y);
        System.out.println(i1);
    }
}

4.原子地更新属性

（1）原子的更新某个类的某个字段时，就需要使用原子更新字段类，Atomic包提供了一下4个类进行原子字段更新。

AtomicIntegerFieldUpdater：原子类int类型更改操作
AtomicLongFieldUpdater：原子类long类型更改操作
AtomicStampedReference：原子类引用类型更改操作，避免ABA问题，携带版本号
AtomicMarkableReference：原子类引用类型更改操作，避免ABA问题，携带boolean值
AtomicReferenceFieldUpdater：原子类引用类型更改操作

（2）AtomicReferenceFieldUpdater、AtomicLongFieldUpdater案例实战

public class Demo2 {
    public static void main(String[] args) {
        Student student = new Student(1L,"李祥");
        //对long类型的数值改变
        AtomicLongFieldUpdater<Student> atomicLongFieldUpdater = AtomicLongFieldUpdater.newUpdater(Student.class,"id");
        //将Student的id改成10
        atomicLongFieldUpdater.compareAndSet(student,1L,10L);
        //输出student的id
        System.out.println("更改student的id："+student.id);
        //对引用类型的改变
        AtomicReferenceFieldUpdater<Student, String> referenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        referenceFieldUpdater.compareAndSet(student,student.getName(),"李祥更改");
        System.out.println("更改student的name："+student.name);
    }
}

public class Student {
        volatile long id;
        volatile String name;
        public Student(long id, String name) {
            this.id = id;
            this.name = name;
        }
        public long getId() {
            return id;
        }
        public void setId(long id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
}

使用原子更新类时注意的问题：

字段必须是volatile类型的，在线程之间共享变量时保证立即可见。
字段的描述类型是调用者与操作对象字段的关系一致，也就是说调用者能够直接操作对象字段，那么就可以反射进行原子操作。
只能是实例变量，不能是类变量，也就是说不能加static关键字。
不能被final变量修饰的。
对于AtomicIntegerFiledUpdater和AtomicLongFieldUpdater只能修改int/long类型的字段，不能修改其他包装类型（Integer\Long）。

修改包装类型就需要使用AtomicRefebceFieldUpdater。

（3）AtomicStampedReference使用

AtomciStampedReference是一个带有时间戳的对象引用，能够很好的解决CAS机制中的ABA问题。
什么是ABA问题

ABA场景案例

public class ABADemo {
    private static AtomicInteger index = new AtomicInteger(10);
    public static void main(String[] args) {
        new Thread(()->{
            index.compareAndSet(10,11);
            index.compareAndSet(11,10);
            System.out.println(Thread.currentThread().getName()+": 进行了 10->11->10");
        },"张三").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
                boolean flag = index.compareAndSet(10, 12);
                System.out.println(Thread.currentThread().getName()+"：修改index结果："+flag+",设置的新值是："+index);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"李祥").start();
    }
}

AtomciStampedReference案例
compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)。
第一个参数expectedReference：表示预期值。
第二个参数newReference：表示要更新的值。
第三个参数expectedStamp：表示预期的时间戳。
第四个参数newStamp：表示要更新的时间戳。

public class AtomicStampedReferenceDemo {
    private static AtomicInteger index = new AtomicInteger(10);
    private static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference(10,1);
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+":当前版本号为："+stampedReference.getStamp());
            stampedReference.compareAndSet(10,11,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+":当前版本号为："+stampedReference.getStamp());
            stampedReference.compareAndSet(11,10,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+":当前版本号为："+stampedReference.getStamp());
        },"张三").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+":拿到的版本号为："+stampedReference.getStamp());
                boolean flag = stampedReference.compareAndSet(10, 12, stampedReference.getStamp(), stampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName()+"：修改index结果："+flag+",设置的新值是："+stampedReference.getReference());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"李祥").start();
    }
}

其实除了AtomicStampedReference类，还有一个原子类也可以解决，就是AtomicMarkableReference，它不是维护一个版本号，而是维护一个boolean类型的标记，用法没有AtomicStampedReference灵活。因此也只是在特定的场景下使用。

【并发编程】原子类

1.什么是原子类

2.原子更新基本类型

3.原子更新数组类型

4.原子地更新属性

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

直播

下载

镜像站

技术资料

【并发编程】原子类

1.什么是原子类

2.原子更新基本类型

3.原子更新数组类型

4.原子地更新属性

热门文章

最新文章

相关电子书