CAS 居然可以代替 synchorinzed

最新推荐文章于 2024-10-16 11:04:30 发布

2401_83817418

最新推荐文章于 2024-10-16 11:04:30 发布

阅读量700

点赞数 10

分类专栏：程序员文章标签：微信

本文链接：https://blog.csdn.net/2401_83817418/article/details/137187283

版权

程序员专栏收录该内容

379 篇文章 1 订阅

订阅专栏

结论：在少量线程且仅需保证单个变量线程安全的情况下可使用 volatile + CAS 替代 volatile + synchorinzed。

注意：volatile + CAS 和 volatile + synchorinzed 使用时要理解它们各自的角色和起到的作用：

volatile：保证有序性和可见性；
CAS、synchorinzed：保证操作原子性。

注意：多线程环境下正确使用 CAS 必须搭配 volatile 关键字。因为 CAS 虽然可以保证原子性，但其无法保证变量在不同线程内存空间的安全性，所以需要 volatile 来保证变量更新对于不同线程是可见的。

ABA 问题

除了上文提到过 CAS 的两个缺点：

仅能保证单个变量操作的原子性；
在高并发情况下 CAS 一直失败会一直重试，浪费 CPU 资源针。对这个问题的一个思路是引入退出机制，如重试次数超过一定阈值后失败退出。当然，更重要的是避免在高并发环境下使用 CAS。

还有一个问题就是 ABA 问题，现有线程 A、B：

线程 1 读取内存中的数据为 A；
线程 2 修改内存数据为 B；
线程 2 修改内存数据为 A；
线程 1 对数据执行 CAS 操作。

由于执行到第四步时内存数据仍然为 A，但其实数据已经被修改过了。这就是 ABA 问题。针对 ABA 问题可以通过引入版本号的方式解决，每次修改内存中的值版本号都 +1，在执行 CAS 操作是不仅比较内存中的值也比较版本号，只有两者都相同时才执行成功。Java 中提供的 java.util.concurrent.atomic.AtomicStampedReference 也是通过版本号来解决 ABA 问题的。

在 Android 中的使用

在 Android 中我们也可以通过 Atomic*** 类来使用 volatile + CAS。

AtomicFile
AtomicInteger
AtomicLong
AtomicBoolean
AtomicReferenceFieldUpdater
AtomicStampedReference

前几个比较好理解，分别可以保证 file、int、long、boolean 类型数据的原子操作，那么如果操作数据为 String 或类型不可知怎么办呢？这时候就可以使用 AtomicReferenceFieldUpdater() 了。在 Kotlin.lazy 的实现中就使用到了 AtomicReferenceFieldUpdater：

private class SafePublicationLazyImpl(initializer: () -> T) : Lazy, Serializable {
@Volatile private var initializer: (() -> T)? = initializer
@Volatile private var _value: Any? = UNINITIALIZED_VALUE
// this final field is required to enable safe initialization of the constructed instance
private val final: Any = UNINITIALIZED_VALUE

override val value: T
get() {
val value = _value
if (value !== UNINITIALIZED_VALUE) {
@Suppress(“UNCHECKED_CAST”)
return value as T
}

val initializerValue = initializer
// if we see null in initializer here, it means that the value is already set by another thread
if (initializerValue != null) {
val newValue = initializerValue()
if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
initializer = null
return newValue
}
}
@Suppress(“UNCHECKED_CAST”)
return _value as T
}

…

companion object {
private val valueUpdater = java.util.concurrent.atomic.AtomicReferenceFieldUpdater.newUpdater(
SafePublicationLazyImpl::class.java,
Any::class.java,
“_value”
)
}
}

AtomicReferenceFieldUpdater 通过静态方法 newUpdater() 获取实例对象。newUpdater() 方法有三个参数，分别是：

tclass：目标变量所在类的 class 对象；
vclass：目标变量的类型 class 对象；
fieldName：目标变量名。

在上述 kotlin.lazy 源码中通过比较初始值，保证在多线程环境中仅第一次赋值有效：

valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)

再来看 AtomicStampedReference，它的初始化方法如下：

public AtomicStampedReference(V initialRef, int initialStamp) {
}

可以看到初始化方法需要两个参数：

初始值
暂且看做初始版本号

用法如下：

private val atomicObj: AtomicStampedReference = AtomicStampedReference(“A”, 0)

val t1 = Thread {
try {
TimeUnit.SECONDS.sleep(1)
} catch (e: InterruptedException) {
}
println(“run thread1”)
atomicObj.compareAndSet(“A”, “B”, atomicObj.stamp, atomicObj.stamp + 1)
atomicObj.compareAndSet(“B”, “A”, atomicObj.stamp, atomicObj.stamp + 1)
}
val t2 = Thread {
val stamp: Int = atomicObj.stamp
try {
TimeUnit.SECONDS.sleep(2)
} catch (e: InterruptedException) {
}
println(“run thread2”)
val result: Boolean = atomicObj.compareAndSet(“A”, “B”, stamp, stamp + 1)
println(result) // false
}
t1.start()
t2.start()
可以看到由于 Thread2 提前获取了版本号，及时 Thread1 执行之后值依然是 A, 但由于版本号已然发生了变化所以 Thread2 的执行结果仍然是 false。