Java并发编程之cas理论（无锁并发）
作者：互联网
文章目录
- 1、共享模型之无锁
- 2、有锁无锁模式对比
- 3、 CAS 与 volatile
- 4、原子整数 (内部通过CAS来实现-AtomicInteger)
- 5、原子引用 (AtomicReference)
- 7、字段更新器
- 8、原子累加器 (LongAddr)
- 9、Unsafe
1、共享模型之无锁
- Java中 synchronized 和 ReentrantLock 等 独占锁 就是 悲观锁 思想的实现
- 在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的
- 管程即monitor是阻塞式的悲观锁实现并发控制，这章我们将通过非阻塞式的乐观锁的来实现并发控制
2、有锁无锁模式对比
题目：共享资源10000元钱，1000个并发，每个10元，结果共享资源剩余为0
使用synchronized保证线程安全
/**
* Description: 使用重量级锁synchronized来保证多线程访问共享资源发生的安全问题
*/
public class Test1 {
public static void main(String[] args) {
Account.demo(new AccountUnsafe(10000));//有锁模式
//Account.demo(new AccountCas(10000));//无锁模式
}
}
class AccountUnsafe implements Account {
private Integer balance;
public AccountUnsafe(Integer balance) {
this.balance = balance;
}
@Override
public Integer getBalance() {
synchronized (this) {
return balance;
}
}
@Override
public void withdraw(Integer amount) {
// 通过这里加锁就可以实现线程安全，不加就会导致线程安全问题
synchronized (this) {
balance -= amount;
}
}
}
interface Account {
// 获取余额
Integer getBalance();
// 取款
void withdraw(Integer amount);
/**
* Java8之后接口新特性, 可以添加默认方法
* 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0
*/
static void demo(Account account) {
List<Thread> ts = new ArrayList<>();
long start = System.nanoTime();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(10);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(account.getBalance()
+ " cost: " + (end - start) / 1000_000 + " ms");
}
}
- 上面的代码中使用synchronized加锁操作来保证线程安全，但是 synchronized加锁操作太耗费资源 (因为底层使用了操作系统mutex指令, 造成内核态和用户态的切换)
使用无锁来解决此问题
class AccountCas implements Account {
//使用原子整数: 底层使用CAS+重试的机制
private AtomicInteger balance;
public AccountCas(int balance) {
this.balance = new AtomicInteger(balance);
}
@Override
public Integer getBalance() {
//得到原子整数的值
return balance.get();
}
@Override
public void withdraw(Integer amount) {
while(true) {
//获得修改前的值
int prev = balance.get();
//获得修改后的值
int next = prev - amount;
//比较并设置值
/*
此时的prev为共享变量的值, 如果prev被别的线程改了
也就是说: 自己读到的共享变量的值 和 共享变量最新值 不匹配,
就继续where(true),如果匹配上了, 将next值设置给共享变量.
AtomicInteger中value属性, 被volatile修饰, 就是为了确保线程之间共享变量的可见性.
*/
if(balance.compareAndSet(prev, next)) {
break;
}
}
}
}
3、 CAS 与 volatile
- 使用原子操作来保证线程访问共享资源的安全性, cas+重试的机制来确保(乐观锁思想)
- 相对于悲观锁思想的synchronized,reentrantLock来说, cas的方式效率会更好
3.1、cas + 重试 的原理
前面看到的AtomicInteger的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？
@Override
public void withdraw(Integer amount) {
// 核心代码
// 需要不断尝试，直到成功为止
while (true){
// 比如拿到了旧值 1000
int prev = balance.get();
// 在这个基础上 1000-10 = 990
int next = prev - amount;
/*
compareAndSet 保证操作共享变量安全性的操作:
① 线程A首先获取balance.get(),拿到当前的balance值prev
② 根据这个prev值 - amount值 = 修改后的值next
③ 调用compareAndSet方法, 首先会判断当初拿到的prev值,是否和现在的
balance值相同;
3.1、如果相同,表示其他线程没有修改balance的值, 此时就可以将next值
设置给balance属性
3.2、如果不相同,表示其他线程也修改了balance值, 此时就设置next值失败,
然后一直重试, 重新获取balance.get()的值,计算出next值,
并判断本次的prev和balnce的值是否相同...重复上面操作
*/
if (atomicInteger.compareAndSet(prev,next)){
break;
}
}
}
- 其中的关键是 compareAndSwap（比较并设置值），它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作
流程 :
- 当一个线程要去修改Account对象中的值时，先获取值prev（调用get方法），然后再将其设置为新的值next（调用cas方法）。在调用cas方法时，会将prev与Account中的余额进行比较
- 如果两者相等，就说明该值还未被其他线程修改，此时便可以进行修改操作
- 如果两者不相等，就不设置值，重新获取值prev（调用get方法），然后再将其设置为新的值next（调用cas方法），直到修改成功为止
注意 :
- 其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的 原子性
- 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的
3.2、volatile的作用
- 在上面代码中的AtomicInteger类，保存值的value属性使用了volatile 修饰。获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰
- volatile可以用来修饰 成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见
- cas必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果
- volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）
3.3、为什么CAS+重试(无锁)效率高
- 使用CAS+重试—无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized会让线程在没有获得锁的时候，发生上下文切换，进入阻塞
1）打个比喻：线程就好像高速跑道上的赛车，高速运行时，速度超快
2）一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速… 恢复到高速运行，代价比较大 - 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换
3.4、CAS 的特点 (乐观锁和悲观锁的特点)
结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下
- CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试
- synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会
- CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思
1）因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
2）但如果竞争激烈(写操作多)，可以想到重试必然频繁发生，反而效率会受影响
4、原子整数 (内部通过CAS来实现-AtomicInteger)
- java.util.concurrent.atomic并发包提供了一些并发工具类
- 使用原子的方式 (共享数据为基本数据类型原子类)
1）AtomicInteger：整型原子类
2）AtomicLong：长整型原子类
3）AtomicBoolean ：布尔型原子类
上面三个类提供的方法几乎相同，所以我们将以 AtomicInteger为例子来介绍。 - 先讨论原子整数类，以 AtomicInteger 为例讨论它的api接口：通过观察源码可以发现
- AtomicInteger 内部都是通过cas的原理来实现的
public static void main(String[] args) {
AtomicInteger i = new AtomicInteger(0);
// 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
System.out.println(i.getAndIncrement());
// 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
System.out.println(i.incrementAndGet());
// 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
System.out.println(i.decrementAndGet());
// 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
System.out.println(i.getAndDecrement());
// 获取并加值（i = 0, 结果 i = 5, 返回 0）
System.out.println(i.getAndAdd(5));
// 加值并获取（i = 5, 结果 i = 0, 返回 0）
System.out.println(i.addAndGet(-5));
// int类型加减乘除操作
// 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
// 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
System.out.println(i.getAndUpdate(p -> p - 2));
// int类型加减乘除操作
// 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
// 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
System.out.println(i.updateAndGet(p -> p + 2));
}
updateAndGet实现原理
public static void main(String[] args) {
AtomicInteger i = new AtomicInteger(5);
updateAndGet(i, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return operand / 2;
}
});
System.out.println(i.get()); // 2
}
public static void updateAndGet(AtomicInteger i, IntUnaryOperator operator) {
while (true) {
int prev = i.get(); // 5
int next = operator.applyAsInt(prev);
if (i.compareAndSet(prev, next)) {
break;
}
}
}
5、原子引用 (AtomicReference)
为什么需要原子引用类型？保证引用类型的共享变量是线程安全
- AtomicReference：引用类型原子类
- AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题
使用原子引用实现BigDecimal存取款的线程安全
public class Test {
//原子BigDecimal引用，总额10000
private static final AtomicReference<BigDecimal> balance
= new AtomicReference<>(new BigDecimal("10000"));
public static void main(String[] args) {
List<Thread> ts = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
//循环创建1000个线程
ts.add(new Thread(() -> {
//每个线程从总额加去10，减法失败则一直while循环重试
while (true) {
BigDecimal prev = balance.get();
BigDecimal next = prev.subtract(new BigDecimal("10"));
if (balance.compareAndSet(prev, next)) {
break;
}
}
}));
}
//启动1000个线程
ts.forEach(Thread::start);
//等待1000个线程执行完，main线程再执行
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//获取总额
System.out.println(balance);
}
}
5.1、ABA 问题及解决
- 如下程序所示，虽然 在other方法中存在两个线程对共享变量进行了修改，但是修改之后又变成了原值，main线程对修改过共享变量的过程是不可见的，这种操作这对业务代码并无影响。
public class Test3 {
public static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) {
new Thread(() -> {
String pre = ref.get();
System.out.println("change");
try {
other();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//把ref中的A改为C
System.out.println("change A->C " + ref.compareAndSet(pre, "C"));
}).start();
}
public static void other() throws InterruptedException {
new Thread(() -> {
// 此时ref.get()为A,此时共享变量ref也是A,没有被改过, 此时CAS
// 可以修改成功, B
System.out.println("change A->B " + ref.compareAndSet(ref.get(), "B"));
}).start();
Thread.sleep(500);
new Thread(() -> {
// 同上, 修改为A
System.out.println("change B->A " + ref.compareAndSet(ref.get(), "A"));
}).start();
}
}
运行结果：
change
change A->B true
change B->A true
change A->C true
Process finished with exit code 0
- 主线程仅能判断出共享变量的值与最初值 A是否相同，不能感知到这种从 A 改为 B 又改回 A 的情况
- 判断值是否相同，是通过地址值==判断
- 如果主线程希望：只要有其它线程【动过】共享变量，那么自己的 cas 就算失败
- 这时，仅比较值是不够的，需要再加一个版本号。使用AtomicStampedReference来解决
5.2、AtomicStampedReference (加版本号解决ABA问题)
public class Test {
//指定版本号
public static AtomicStampedReference<String> ref
= new AtomicStampedReference<>("A", 0);
public static void main(String[] args) {
new Thread(() -> {
String pre = ref.getReference();
//获得版本号
int stamp = ref.getStamp(); // 此时的版本号还是第一次获取的
System.out.println("change");
try {
other();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//把ref中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
System.out.println("change A->C stamp " +
stamp + ref.compareAndSet(pre, "C", stamp, stamp + 1));
}).start();
}
public static void other() throws InterruptedException {
new Thread(() -> {
int stamp = ref.getStamp();
System.out.println("change A->B stamp " +
stamp + ref.compareAndSet(ref.getReference(), "B", stamp, stamp + 1));
}).start();
Thread.sleep(500);
new Thread(() -> {
int stamp = ref.getStamp();
System.out.println("change B->A stamp " +
stamp + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
}).start();
}
}
运行结果：
change
change A->B stamp 0true
change B->A stamp 1true
change A->C stamp 0false
Process finished with exit code 0
5.3、AtomicMarkableReference (标记cas的共享变量是否被修改过)
- AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如：A -> B -> A ->C，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次
- 但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过（true/false），所以就有了AtomicMarkableReference
public class Test {
//指定标记，起始为true，当变为fals，则证明修改过
public static AtomicMarkableReference<String> ref =
new AtomicMarkableReference<>("A", true);
public static void main(String[] args) {
new Thread(() -> {
String pre = ref.getReference();
System.out.println("change");
try {
other();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//把str中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
System.out.println("change A->C mark " +
ref.compareAndSet(pre, "C", true, false));
}).start();
}
public static void other() throws InterruptedException {
new Thread(() -> {
System.out.println("change A->A mark " + ref.compareAndSet(
ref.getReference(), "A", true, false));
}).start();
}
}
执行结果：
change
change A->A mark true
change A->C mark false
Process finished with exit code 0
5.4、AtomicStampedReference和AtomicMarkableReference两者的区别
- AtomicStampedReference 需要我们传入整型变量 作为版本号，来判定是否被更改过
- AtomicMarkableReference需要我们传入布尔变量 作为标记，来判断是否被更改过
6、原子数组 (AtomicIntegerArray)
- 保证数组内的元素的线程安全
- 使用原子的方式更新数组里的某个元素
1）AtomicIntegerArray：整形数组原子类
2）AtomicLongArray：长整形数组原子类
3）AtomicReferenceArray：引用类型数组原子类
上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍
普通数组内元素, 多线程访问造成安全问题
- 创建一个数组，10个元素
- 创建10个线程，每个线程对数组每个元素操作10000次
- 每次为每个元素+1
public class AtomicArrayTest {
public static void main(String[] args) {
demo(
() -> new int[10],
array -> array.length,
(array, index) -> array[index]++,
array -> System.out.println(Arrays.toString(array))
);
}
/**
* 参数1，提供数组、可以是线程不安全数组或线程安全数组
* 参数2，获取数组长度的方法
* 参数3，自增方法，回传 array, index
* 参数4，打印数组的方法
*/
// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
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++) {
// 创建10个线程, 每个线程对数组作 10000 次操作
ts.add(new Thread(() -> {
for (int j = 0; j < 10000; j++) {
putConsumer.accept(array, j % length);
}
}));
}
// 启动所有线程
ts.forEach(Thread::start);
// 等所有线程结束,再执行main线程
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
printConsumer.accept(array);
}
}
执行结果：
[8374, 8170, 8091, 8031, 8029, 7981, 8276, 8405, 8434, 8504]
Process finished with exit code 0
使用AtomicIntegerArray来创建安全数组
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]
Process finished with exit code 0
7、字段更新器
保证多线程访问同一个对象的成员变量时, 成员变量的线程安全性
- AtomicReferenceFieldUpdater —引用类型的属性
- AtomicIntegerFieldUpdater —整形的属性
- AtomicLongFieldUpdater —长整形的属性
注意：利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常
Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type
示例
public class AtomicFieldTest {
public static void main(String[] args) {
Student stu = new Student();
// 获得原子更新器
// 泛型
// 参数1 持有属性的类 参数2 被更新的属性的类
// newUpdater中的参数：第三个为属性的名称
AtomicReferenceFieldUpdater updater =
AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
// 期望的为null, 如果name属性没有被别的线程更改过, 默认就为null, 此时匹配, 就可以设置name为张三
System.out.println(updater.compareAndSet(stu, null, "张三"));
System.out.println(updater.compareAndSet(stu, stu.name, "王五"));
System.out.println(stu);
}
}
class Student {
volatile String name;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
运行结果：
true
true
Student{name='王五'}
Process finished with exit code 0
8、原子累加器 (LongAddr)
- LongAddr
- LongAccumulator
- DoubleAddr
- DoubleAccumulator
累加器性能比较 AtomicLong, LongAddr
public class Test {
public static void main(String[] args) {
System.out.println("----AtomicLong----");
demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
System.out.println("----LongAdder----");
demo(() -> new LongAdder(), adder -> adder.increment());
}
private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
T adder = adderSupplier.get();
long start = System.nanoTime();
List<Thread> ts = new ArrayList<>();
// 40 个线程，每人累加 50 万
for (int i = 0; i < 40; i++) {
ts.add(new Thread(() -> {
for (int j = 0; j < 500000; j++) {
action.accept(adder);
}
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(adder + " 耗时:" + (end - start) / 1000_000);
}
}
运行结果：
----AtomicLong----
20000000 耗时:390
----LongAdder----
20000000 耗时:44
Process finished with exit code 0
- LongAddr：性能提升的原因很简单，就是在有竞争时，设置多个累加单元(但不会超过cpu的核心数)，Therad-0 累加 Cell[0]，而 Thread-1 累加Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性能
- AtomicLong：都是在一个共享资源变量上进行竞争, while(true)循环进行CAS重试, 性能没有LongAdder高
9、Unsafe
- Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得
- 可以发现AtomicInteger以及其他的原子类, 底层都使用的是Unsafe类
底层的Unsafe实现原子操作
public class Test {
public static void main(String[] args) throws Exception {
// 通过反射获得Unsafe对象
Class<Unsafe> unsafeClass = Unsafe.class;
// 获得构造函数，Unsafe的构造函数为私有的
Constructor<Unsafe> constructor = unsafeClass.getDeclaredConstructor();
// 设置为允许访问私有内容
constructor.setAccessible(true);
// 创建Unsafe对象
Unsafe unsafe = constructor.newInstance();
// 创建Person对象
Person person = new Person();
// 获得其属性 name 的偏移量
long nameOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("name"));
long ageOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("age"));
// 通过unsafe的CAS操作改变值
unsafe.compareAndSwapObject(person, nameOffset, null, "guizy");
unsafe.compareAndSwapInt(person, ageOffset, 0, 22);
System.out.println(person);
}
}
class Person {
// 配合CAS操作，必须用volatile修饰
volatile String name;
volatile int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
运行结果：
Person{name='guizy', age=22}
Process finished with exit code 0
9.1、AtomicInteger累加源码
以AtomicInteger类incrementAndGet()方法（int+1返回更新值）为例
public class Test {
public static void main(String[] args) {
AtomicInteger i = new AtomicInteger(10);
int i1 = i.incrementAndGet();
System.out.println(i1);
}
}
运行结果：
11
Process finished with exit code 0
源码分析
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// 获取Unsafe类
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 通过Unsafe类获取value偏移量
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
/**
* 累加1，并返回累加后的int值
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/**
* this：本对象，即toString(),这里即为int值
*/
public String toString() {
return Integer.toString(get());
}
/**
* 获取value值
*/
public int intValue() {
return get();
}
}
unsafe.getAndAddInt(this, valueOffset, 1)方法
- var1：this，这里则为10
- var2：valueOffset（value值的偏移量）
- var4：累加，即这里为1
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
//通过value值的偏移量获取value的最新值
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
- compareAndSwapInt：通过偏移值获取最新value值与之前获取的当时最新值var5比较
- 如果相同，则将value值+var4（这里是1），!compareAndSwapInt=false，跳出循环
- 如果不同，value+1失败，!compareAndSwapInt=true，继续进入do循环去获取最新值
标签：无锁,Java,int,System,并发,线程,println,new,public 来源： https://blog.csdn.net/qq_35512802/article/details/123010355