Java并发学习笔记（五）：乐观锁、CAS(比较交换)使用和原理、原子整数、原子引用、原子数组、原子累加器、Unsafe

乐观锁（非阻塞）

一、CAS（比较交换） 与 volatile

1、引入

现在需要在多线程的情况下对一个账户扣款操作，除了使用synchronized方法， 还可以使用AtomicInteger 的解决问题：

    private AtomicInteger balance;
 
	...
	
	public void withdraw(Integer amount) {
        // 需要不断尝试，直到成功为止
        while (true) {
            int prev = balance.get();
            int next = prev - amount;            
			//进行比较设置
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }

AtomicInteger::compareAndSet内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？

2、原理

其实compareAndSet方法的名字已经说明了，它的执行原理是：

• compareAndSet 方法在设置 amount的值为next，前做了个检查，先比较 prev 与主内存中amount当前值
• 不一致了，next 作废，返回 false 表示失败
• 一致，以 next 设置为新值，返回 true 表示成功

其中的关键是 compareAndSet，它的简称就是 CAS （也有 Compare And Swap （比较交换）的说法），它必须是原子操作（操作系统保证）。CAS是乐观锁一种。下图用时序图表示了compareAndSet在上面代码中的工作流程：

• 当线程1从主内存获得余额为100并对其减10得到90之后，其他线程已经将余额更改了90，那么执行compareAndSet(100,90)时，将prev与主内存中余额的值比较之后发现不一样，则next作废，返回false。（下一次循环同理）

• 当线程1从主内存获得余额为80并对其减10得到70之后，执行compareAndSet(80,70)时，发现主内存中也是80，说明可进行设置，就将余额的值设为70，并返回true。
  
  注意：

• 其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。

• 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再 开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子 的。

3、CAS与volatile 的关系

CAS 必须借助 volatile 才能读取到共享变量的新值来实现【比较并交换】的效果 。主要用于保证线程更新共享变量之后必须写回主内存，并且在比较时获取到主内存中共享变量的值

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。可以看到AtomicInteger中的值就被设置为volatile 的

注意：volatile 仅仅保证了共享变量的可见性，让其它线程能够看到新值，但不能解决指令交错问题（不能保证原 子性）

4、CAS效率

与synchronized 相比无锁的CAS在多核情况下更加高效。原因：

• 无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时 候，发生上下文切换，进入阻塞，代价比较大
• 但无锁情况下，因为线程要保持运行，需要多核 CPU 的支持。在单核CPU下，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

5、CAS 的特点

结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

• CAS 是基于乐观锁的思想：乐观的估计，不担心别的线程来修改共享变量，就算改了最多重试，不会产生错误的结果。
• synchronized 是基于悲观锁的思想：悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想 改，我改完了解开锁，你们才有机会。
• CAS 体现的是无锁并发、无阻塞并发
  • 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
  • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

二、原子整数

J.U.C 并发包提供了很多原子类型，可以分为原子整数、原子引用、源自数组、字段更新器、原子累加器等。

其中J.U.C 并发包的原子整数包括：

• AtomicBoolean
• AtomicInteger
• AtomicLong

以AtomicInteger 为例，主要有以下操作：

AtomicInteger a = new AtomicInteger(10);

//先获取再++，类似++i
a.incrementAndGet();
//先++再获取，类似i++
a.getAndIncrement();

//先增加5再获取
a.addAndGet(5);
//先获取再增加5
a.getAndAdd(5);

//进行进行运算，再获得值
a.updateAndGet(x -> x * 5);
//进行获得值，再进行运算
a.getAndUpdate(x -> x * 5);

a.get();

前四个都比较容易理解，对于updateAndGet，我们可以看看它的源码：

    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

看源码可以发现，它的实现方式和我们上面扣余额的方式十分相似。都是根据prev计算出next之手，使用CAS

（compareAndSet函数）进行比较和设置。只不过其中的计算过程不是写死的，而是通过IntUnaryOperator接口设置的，我们看一下applyAsInt方法：

@FunctionalInterface
public interface IntUnaryOperator {

    /**
     * Applies this operator to the given operand.
     *
     * @param operand the operand
     * @return the operator result
     */
    int applyAsInt(int operand);
    
    ...
}

我们可以使用Lambda去重写applyAsInt函数，之后在updateAndGet函数就能够调用了。

三、原子引用

1、简单实用

对于最开始的取款操作，如果我需要小数级别就不能使用AtomicInteger，而且也没有对应的原子小数。这时候就要用到源自引用了，它主要包括：

• AtomicReference
• AtomicMarkableReference
• AtomicStampedReference

我先看看如何使用AtomicReference 实现小数级别的取款操作：

class DecimalAccountSafeCas implements DecimalAccount {
    AtomicReference<BigDecimal> ref;

    public DecimalAccountSafeCas(BigDecimal balance) {
        ref = new AtomicReference<>(balance);
    }

    @Override
    public BigDecimal getBalance() {
        return ref.get();
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = ref.get();
            BigDecimal next = prev.subtract(amount);
            if (ref.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

可以看到AtomicReference使用泛型对AtomicReference<BigDecimal>进行定义，其余操作和我们之前看到没有区别。

2、ABA问题

AtomicReference其实还有一个问题就是compareAndSet函数只能比较prev和主内存中共享变量当前的值是否一致，并不能确定主内存中共享变量是否改变过，例如另一个线程先把共享变量的值从A改为B，再从B改为A。如果使用AtomicReference，这个过程对于本线程是无法感知的，这个问题就被称为ABA问题。例如：

    static AtomicReference<String> ref = new AtomicReference<>("A");

    public static void main(String[] args) throws InterruptedException {
        log.debug("main start...");
        // 获取值 A    
        // 这个共享变量被它线程修改过？ 
        String prev = ref.get();
        other();
        sleep(1);
        // 尝试改为 C
        log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
    }

    private static void other() {
        new Thread(() -> {
            log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
        }, "t1").start();
        sleep(0.5);
        new Thread(() -> {
            log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
        }, "t2").start();
    }

结果:

11:29:52.325 c.Test36 [main] - main start... 
11:29:52.379 c.Test36 [t1] - change A->B true 
11:29:52.879 c.Test36 [t2] - change B->A true 
11:29:53.880 c.Test36 [main] - change A->C true 

主线程仅能判断出共享变量的值与初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，如果主线程 希望：只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号

这时就可以使用AtomicStampedReference进行解决，AtomicStampedReference为共享变量增加了一个版本号，每次改动时都判断版本号是否对应，不一致的情况下不能改动：

    static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

    public static void main(String[] args) throws InterruptedException {
        log.debug("main start...");
        String prev = ref.getReference();
        int stamp = ref.getStamp();
        log.debug("版本 {}", stamp);
        other();
        sleep(1);
        log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
    }

    private static void other() {
        new Thread(() -> {
            log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", ref.getStamp(), ref.getStamp() + 1));
            log.debug("更新版本为 {}", ref.getStamp());
        }, "t1").start();
        sleep(0.5);
        new Thread(() -> {
            log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", ref.getStamp(), ref.getStamp() + 1));
            log.debug("更新版本为 {}", ref.getStamp());
        }, "t2").start();
    }

结果：

15:41:34.891 c.Test36 [main] - main start... 
15:41:34.894 c.Test36 [main] - 版本 0 
15:41:34.956 c.Test36 [t1] - change A->B true 
15:41:34.956 c.Test36 [t1] - 更新版本为 1 
15:41:35.457 c.Test36 [t2] - change B->A true 
15:41:35.457 c.Test36 [t2] - 更新版本为 2 
15:41:36.457 c.Test36 [main] - change A->C false

AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如： A -> B -> A -> C ，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。

但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，就可以使用AtomicMarkableReference，下面以倒下图的垃圾流程为例看看它如何使用：

示例代码：

@Slf4j
public class TestABAAtomicMarkableReference {
    public static void main(String[] args) throws InterruptedException {
        GarbageBag bag = new GarbageBag("装满了垃圾");
        // 参数2 mark 可以看作一个标记，表示垃圾袋满了 
        AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);

        log.debug("主线程 start...");
        GarbageBag prev = ref.getReference();
        log.debug(prev.toString());

        new Thread(() -> {
            log.debug("打扫卫生的线程 start...");
            bag.setDesc("空垃圾袋");
            while (!ref.compareAndSet(bag, bag, true, false)) {
            }
            log.debug(bag.toString());
        }).start();

        Thread.sleep(1000);
        log.debug("主线程想换一只新垃圾袋？");
        boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
        log.debug("换了么？" + success);

        log.debug(ref.getReference().toString());
    }
}

结果：

2019-10-13 15:30:09.264 [main] 主线程 start... 
2019-10-13 15:30:09.270 [main] cn.itcast.GarbageBag@5f0fd5a0 装满了垃圾 
2019-10-13 15:30:09.293 [Thread-1] 打扫卫生的线程 start... 
2019-10-13 15:30:09.294 [Thread-1] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋 
2019-10-13 15:30:10.294 [main] 主线程想换一只新垃圾袋？ 
2019-10-13 15:30:10.294 [main] 换了么？false 
2019-10-13 15:30:10.294 [main] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋 

可以看到当副线程把状态该了之后，主线程就无法再修改GarbageBag的值了。

四、原子数组

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

有如下方法：

    /**     
        参数1，提供数组、可以是线程不安全数组或线程安全数组     
        参数2，获取数组长度的方法     
        参数3，自增方法，回传 array, index     
        参数4，打印数组的方法 
    */ 
	// supplier 提供者 无中生有  ()->结果 
	// function 函数   一个参数一个结果   (参数)->结果  ,  BiFunction (参数1,参数2)->结果 
	// consumer 消费者 一个参数没结果  (参数)->void,      BiConsumer (参数1,参数2)-> 
	private static <T> void demo(Supplier<T> arraySupplier, 
    					Function<T, Integer> lengthFun, 
    					BiConsumer<T, Integer> putConsumer, 
    					Consumer<T> printConsumer) {
        List<Thread> ts = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);
        for (int i = 0; i < length; i++) {
            ts.add(new Thread(() -> {
             	// 每个线程对数组作 10000 次操作 
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }

        ts.forEach(t -> t.start());// 启动所有线程 
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }); // 等所有线程结束 
        printConsumer.accept(array);
    }

不安全的数组

demo(    
	()->new int[10],    
	(array)->array.length,    
	(array, index) -> array[index]++,    
	array-> System.out.println(Arrays.toString(array)) 
);

结果：

[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]

安全数组

demo(
	()->new AtomicIntegerArray(10),
	(array)->array.length(),
	(array, index) -> array.getAndIncrement(index),
	array -> System.out.println(array) 
);

结果:

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000] 

五、 字段更新器

• AtomicReferenceFieldUpdater // 域 字段
• AtomicIntegerFieldUpdater
• AtomicLongFieldUpdate

利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现 异常

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

示例代码：

public class Test5 {

    //注意属性上必须加上volatile
    private volatile int field;

    public static void main(String[] args) {

        AtomicIntegerFieldUpdater fieldUpdater =
                AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");

        Test5 test5 = new Test5();
        
        // 修改成功 field = 10 
        fieldUpdater.compareAndSet(test5, 0, 10);
        System.out.println(test5.field);
        
		// 修改成功 field = 20 
        fieldUpdater.compareAndSet(test5, 10, 20);
        System.out.println(test5.field);

        // 修改失败 field = 20
        fieldUpdater.compareAndSet(test5, 10, 30);
        System.out.println(test5.field);
    }
}

结果：

10 20 20 

五、原子累加器

private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
    T adder = adderSupplier.get();

    long start = System.nanoTime();
    
	// 4 个线程，每人累加 50 万 
    List<Thread> ts = new ArrayList<>();
    for (int i = 0; i < 40; i++) {
        ts.add(new Thread(() -> {
            for (int j = 0; j < 500000; j++) {
                action.accept(adder);
            }
        }));
    }
    ts.forEach(t -> t.start());
    ts.forEach(t -> {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    long end = System.nanoTime();
    System.out.println(adder + " cost:" + (end - start) / 1000_000);
}

比较 AtomicLong 与 LongAdder

for (int i = 0; i < 5; i++) {
	demo(() -> new LongAdder(), adder -> adder.increment());
}

for (int i = 0; i < 5; i++) {
	demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
}

结果：

1000000 cost:43 
1000000 cost:9 
1000000 cost:7 
1000000 cost:7 
1000000 cost:7 
 
1000000 cost:31 
1000000 cost:27 
1000000 cost:28 
1000000 cost:24 
1000000 cost:22 

性能提升的原因很简单，就是在有竞争时，LongAdder设置多个累加单元，Therad-0 累加 Cell[0]，而 Thread-1 累加 Cell[1]… 后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性 能。

六、Unsafe

Unsafe 对象提供了非常底层的，操作内存、线程的方法。相关原子类都是通过Unsafe 提供的方法实现的。Unsafe 对象不能直接调用，只能通过反射获得。

        //获得反射获取Unsafe对象
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);

Unsafe 执行CAS 操作

        //获得反射获取Unsafe对象
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);

        //1、获得域的偏移地址
        long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
        long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));

        Teacher teacher = new Teacher();
        //2、执行 CAS 操作
        unsafe.compareAndSwapInt(teacher, idOffset, 0, 1);
        unsafe.compareAndSwapObject(teacher, nameOffset, null, "小红");

        System.out.println(teacher);

输出：

Teacher{id=1, name='小红'}
     Unsafe unsafe = (Unsafe) field.get(null);

        //1、获得域的偏移地址
        long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
        long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));

        Teacher teacher = new Teacher();
        //2、执行 CAS 操作
        unsafe.compareAndSwapInt(teacher, idOffset, 0, 1);
        unsafe.compareAndSwapObject(teacher, nameOffset, null, "小红");

        System.out.println(teacher);

输出：

Teacher{id=1, name='小红'}