bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第八章——原子操作类之18罗汉增强

原子操作类之18罗汉增强

是什么

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

Atomic相关类

参考阿里巴巴操作手册

17.【参考】volatile解决多线程内存不可见问题对于一写多读，是可以解决变量同步问题，但是如果多写，同样无法解决线程安全问题

说明：如果是count++操作，使用如下类实现：

AtomicInteger count = new AtomicInteger();
count.addAndGet(1);

如果是JDK8，推荐使用LongAdder对象，比AtomicLong性能更好（减少乐观锁的重试次数）

再分类

基本类型原子类

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

常用API简介

public final int get() //获取当前的值
public final int getAndSet(int newValue) //获取当前的值，并设置新的值
public final int getAndIncrement() //获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue) //最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值

Case

CountDownLatch代替sleep

package com.bilibili.juc.atomic;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerDemo {
   
   

    public static final int SIZE = 50;

    public static void main(String[] args) throws InterruptedException {
   
   
        MyNumber myNumber = new MyNumber();

        CountDownLatch countDownLatch = new CountDownLatch(SIZE);

        for (int i = 0; i < SIZE; i++) {
   
   
            new Thread(() -> {
   
   
                try {
   
   
                    for (int j = 0; j < 1000; j++) {
   
   
                        myNumber.addPlusPlus();
                    }
                } finally {
   
   
                    countDownLatch.countDown();
                }
            }, String.valueOf(i)).start();
        }

        // 等待上面50个线程全部计算完成后，再去获得最终结果
        // 暂停2秒（低级解决方法，实际工作中不可这样使用）
//        try {
   
   
//            TimeUnit.SECONDS.sleep(2);
//        } catch (InterruptedException e) {
   
   
//            e.printStackTrace();
//        }

        countDownLatch.await();

        System.out.println(Thread.currentThread().getName() + "\t" + "result：" + myNumber.atomicInteger.get());
    }

}

class MyNumber {
   
   
    AtomicInteger atomicInteger = new AtomicInteger();

    public void addPlusPlus() {
   
   
        atomicInteger.getAndIncrement();
    }
}

输出结果：
main	result：50000

数组类型原子类

• AtomicIntegerArray：整型数组原子类
• AtomicLongrArray：长整型数组原子类
• AtomicReferenceArray：用类型数组原子类

常用API简介

public final int get(int i) //获取 index=i 位置元素的值
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
public final int getAndAdd(int i, int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值

Case

package com.bilibili.juc.atomic;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicIntegerArrayDemo {
   
   

    public static void main(String[] args) {
   
   
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[5]);
//        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(5);
//        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[]{1,2,3,4,5});

        for (int i = 0; i < atomicIntegerArray.length(); i++) {
   
   
            System.out.println(atomicIntegerArray.get(i));
        }

        int tmpInt = 0;

        tmpInt = atomicIntegerArray.getAndSet(0, 1122);
        System.out.println(tmpInt + "\t" + atomicIntegerArray.get(0));

        tmpInt = atomicIntegerArray.getAndIncrement(0);
        System.out.println(tmpInt + "\t" + atomicIntegerArray.get(0));
    }

}

输出结果：
0
0
0
0
0
0	1122
1122	1123

引用类型原子类

• AtomicReference：引用类型原子类
• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题
  • 解决修改过几次
• AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来
  • 解决是否修改过，它的定义就是将标记戳简化为true/false，类似于一次性筷子

Case

package com.bilibili.juc.atomic;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicMarkableReference;

public class AtomicMarkableReferenceDemo {
   
   

    static AtomicMarkableReference atomicMarkableReference = new AtomicMarkableReference(100, false);

    public static void main(String[] args) {
   
   
        new Thread(() -> {
   
   
            boolean marked = atomicMarkableReference.isMarked();
            System.out.println(Thread.currentThread().getName() + "\t" + "默认标识：" + marked);

            // 暂停1s，等待后面的t2线程和我拿到一样的默认marked标识，都是false
            try {
   
   
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
   
   
                e.printStackTrace();
            }

            boolean result = atomicMarkableReference.compareAndSet(100, 1000, marked, !marked);
            System.out.println(Thread.currentThread().getName() + "\t" + "线程CAS结果：" + result);
            System.out.println(Thread.currentThread(