【JavaEE】线程安全(一).4:写块串行保安全、CAS

|--------------------------------------------------------------------|--------------------------------------------|
| 写块 | ++写对象++ 并发写波及安全维护的代码块 |
| 官路 | 相对无法被穿插 的 ++串行++执行块 |
| 官内口 | 开在串行执行块++内部++ 的入口 |
| 渡路 | 相对可以被穿插 的 ++并发++执行块 |
| 并发标志位 | 检查写对象****值变化 推断是否被并发执行修改 |
| 可回溯写对象 | 值可以往回修改的写对象 |
| CAS | compare and swap，比较和交换 $**赋值**$ |
[注释]

一、线程安全(一).4:写块串行保安全

知识连接**:**

线程安全(一).1:不安全原因和措施

线程安全(一).2:指令全排序

线程安全(一).3:条件产生渡送执行

线程安全(一).5:总

++默认并发环境++ 下，有修改的并发写 ++如果++ 有危险需写块设在++官路上串行++ 保障安全

1.官内口串行读取读检

串行读取可以 读准确值 与 检无并发，两者能 互相独立 地实现 ++保障并发写的安全++

1.1读准确值

临时官上串行读取 时 前渡路已插改完 、后官路暂无插改 读取写对象当时终新的准确值

1.2检无并发

在**++渡路上并发当时++ 地读取++设立++** 并在**++官内口串行精确++ 地读取++对比++** 前后非回溯写对象并发标志位的值变化 ++检查此端渡路有无并发++

1.2.1可回溯ABA并发

可回溯写对象作并发标志位会ABA并发 后 前后值相等 而++错误检未并发++

2.官路上串行写入修改

(3)官路来源

(3).1加锁

加锁****造官路

(3).2原子指令

原子指令****自带官路

(4)渡路上并发读取筛送

(4).1加锁官需要

加锁造官路 有开销 需在渡路上并发当时地读取筛排 ++少送至些++

(4).2原子指令官不需要

CAS原子指令的官路 无开销 渡路上的全部送至 ++都无所谓的++

二、CAS原子指令

1.来源

|----------|--------|----------|------------|-------|
| CAS原子指令➡ | C++代码➡ | JVM本地方法➡ | Unsafe类接口➡ | 原子类方法 |
[Java中CAS来源的过程]

1.1CAS原子指令 -> C++代码

CPU的CAS原子指令 暴露给用户态 C++可以直接执行

1.2C++代码 -> JVM本地方法

JVM的本地方法 调用执行C++代码

1.3JVM本地方法 -> Unsafe类接口

Unsafe类 封装提供 调用JVM本地方法 的接口

1.4Unsafe类接口 -> 原子类方法

原子类封装 Unsafe类的本地接口方法 在方法底层调用使用

2.内容

java 复制代码

boolean CAS(address, expectValue, swapValue) {

    if (&address == expectValue) { // 比较

        &address = swapValue; // 交换

        return true;

    }

    return false;

}

CAS原子指令自带零开销官路，里面有写块 进行了 串行读取读检与串行写入修改 ++保障了安全++

3.实现

3.1原子类

3.1.1安全保障

3.1.1.1串行读取(读准确值、检无并发)

在渡路上并发当时地读取设立、在CAS官内口串行精确地读取对比 前后 标志位写对象 的值变化检查有无并发

3.1.1.2串行写入

3.1.1.2.1无并发

无并发 算术串行修改写对象，返回true 算术修改成功 ++退出 重复读检无并发而算术修改的循环++

3.1.1.2.2有并发

有并发 不串行修改 返回false ++重新循环 算术修改的写块++

3.1.2使用

java 复制代码

public static void main(String[] args) {
    AtomicInteger count = new AtomicInteger(1); // count初始值1

    // ++
    System.out.println(count.getAndIncrement());; // i = 1, i++, return 1, i -> 2
    System.out.println(count.incrementAndGet()); // i = 2, ++i, return 3, i -> 3

    // --
    System.out.println(count.getAndDecrement()); // i = 3, i--, return 3, i -> 2
    System.out.println(count.decrementAndGet()); // i = 2, --i, return 1, i -> 1

    // +=
    System.out.println(count.getAndAdd(7)); // i = 1, i+=7, return 1, i -> 8
    System.out.println(count.addAndGet(-7)); // i = 8, i-=7, return 1, i -> 1
}

3.1.2.1++

3.1.2.1.1getAndIncrement() <=> i++

先获取 旧值 再自增1，返回自增前的数值

3.1.2.1.2incrementAndGet() <=> ++i

先自增1 再获取新值，返回自增后的数值

3.1.2.2--

3.1.2.2.1getAndDecrement() <=> i--

先获取 旧值 再自减1，返回自减前的数值

3.1.2.2.2decrementAndGet() <=> --i

先自减1 再获取新值，返回自减后的数值

3.1.2.3+=/-=

3.1.2.3.1getAndAdd(int delta) <=> i += delta, return i

先获取 旧值 再自增(+-)delta，返回自增前的数值

3.1.2.3.2addAndGet(int delta) <=> i += delta, return i+delta

先自增(+-)delta 再获取新值，返回自增后的数值

3.2自旋锁

3.2.1串行读取(读准确值)

++不关心有无并发++ 在CAS官内口串行精确地读取锁对象的占用线程成员写对象的值，与null空值比较相等查看锁是否被线程占据

3.2.2串行写入

3.2.2.1未占据

未占据 赋当前线程串行修改写对象，返回true 占据锁修改成功 ++退出 忙等读查锁占空而占据修改的空循环++

3.2.2.2已占据

遇占据 不串行修改 返回false ++重新循环 占据修改的写块++