java AtomicLong原理解析

最新推荐文章于 2024-09-29 11:18:32 发布

one_zheng

最新推荐文章于 2024-09-29 11:18:32 发布

阅读量417

点赞数 1

分类专栏：初入皮毛文章标签： java 线程

初入皮毛专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文深入探讨了乐观锁和悲观锁的概念及其应用场景，对比了它们与独占锁的区别，并详细解析了Java中的原子操作、volatile变量的特点及限制。此外，还介绍了CAS无锁算法的工作原理，以及其在JVM中的具体实现。

摘要由CSDN通过智能技术生成

摘自

http://www.tuicool.com/articles/zuui6z
乐观锁与悲观锁

独占锁是一种悲观锁，synchronized就是一种独占锁，它假设最坏的情况，并且只有在确保其它线程不会造成干扰的情况下执行，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

volatile的问题

与锁相比，volatile变量是一和更轻量级的同步机制，因为在使用这些变量时不会发生上下文切换和线程调度等操作，但是volatile变量也存在一些局限：不能用于构建原子的复合操作，因此当一个变量依赖旧值时就不能使用volatile变量。（参考：谈谈volatiile）

Java中的原子操作( atomic operations)

原子操作指的是在一步之内就完成而且不能被中断。原子操作在多线程环境中是线程安全的，无需考虑同步的问题。在java中，下列操作是原子操作：

all assignments of primitive types except for long and double
all assignments of references
all operations of java.concurrent.Atomic* classes
all assignments to volatile longs and doubles
问题来了，为什么long型赋值不是原子操作呢？例如：

long foo = 65465498L;
实时上java会分两步写入这个long变量，先写32位，再写后32位。这样就线程不安全了。如果改成下面的就线程安全了：

private volatile long foo;
因为volatile内部已经做了synchronized.

CAS无锁算法

要实现无锁（lock-free）的非阻塞算法有多种实现方法，其中 CAS（比较与交换，Compare and swap）是一种有名的无锁算法。CAS, CPU指令，在大多数处理器架构，包括IA32、Space中采用的都是CAS指令，CAS的语义是“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉V的值实际为多少”，CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS无锁算法的C实现如下：

int compare_and_swap (int* reg, int oldval, int newval)
{
ATOMIC();
int old_reg_val = *reg;
if (old_reg_val == oldval)
*reg = newval;
END_ATOMIC();
return old_reg_val;
}
CAS（乐观锁算法）的基本假设前提

CAS比较与交换的伪代码可以表示为：

do{
备份旧数据；
基于旧数据构造新数据；
}while(!CAS( 内存地址，备份的旧数据，新数据 ))

就是指当两者进行比较时，如果相等，则证明共享数据没有被修改，替换成新值，然后继续往下运行；如果不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作。容易看出 CAS 操作是基于共享数据不会被修改的假设，采用了类似于数据库的 commit-retry 的模式。当同步冲突出现的机会很少时，这种假设能带来较大的性能提升。

JVM对CAS的支持：AtomicInt, AtomicLong.incrementAndGet()

复制代码
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
　　
private volatile long value //value设置为volatile变量，目的是每次变量的值变更时，其他线程再取该值时，始终为内存中最新的值

public final long getAndIncrement() {

　　　　//不加锁，当设置失败时，利用死循环，再次尝试，直至设置成功
while (true) {
long current = get();
long next = current + 1;
　　　　　　 //调用compareAndSet方法
if (compareAndSet(current, next))
return current;
}
} /**
复制代码
复制代码
* Atomically sets the value to the given updated value
* if the current value {@code ==} the expected value.
*
* @param expect the expected value
* @param update the new value
* @return true if successful. False return indicates that
* the actual value was not equal to the expected value.
*/

public final boolean compareAndSet(long expect, long update) {

　　　　//valueOffSet为内存中的值，expect的值为旧的预期值，该线程执行getAndIncrement()函数时，通过get()获取的当时的变量值
　　　 //update=expect+1
　　　 // 只有valueOffset=expect时才会把变量的值设置为update，设置成功返回true，否则返回false
　　　return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
复制代码

二、ABA问题

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B，然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。如果链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。因此前面提到的原子操作AtomicStampedReference/AtomicMarkableReference就很有用了。这允许一对变化的元素进行原子操作。