CAS无锁策略

  在并发编程中,对于共享资源的使用需要确保绝对的安全性。除了利用锁机制之外,还有一种无锁的概念。所谓无锁,就是假定在并发情况下,对于共享资源的访问没有冲突,线程可以一直不停的运行,无需阻塞,如果产生冲突,则使用CAS算法确保安全性。Java在很多并发代码中都使用了这种算法。

  CAS算法的核心参数如下:

compareAndSet(V,E,A)

  V代码需要进行更新的变量;E代表预期值;A代表所要更新的值。

  CAS的核心思想就是:当要对一个变量进行更新时,先取出该变量此时在内存中的实际值,与预期值进行比较。如果相等,则代表没有其他线程对其进行过修改,直接更新。如果不同,表示有其他线程修改过,此时有两种策略。一种是让CAS自旋,直到更新成功;另外表示当前线程更新失败,继续后续逻辑。大概示意图如下:

  对于CAS自旋,有可能会出现长时间更新失败,浪费CPU性能的情况。JDK1.6以后,加入了适应性自旋的概念。即如果某个锁自旋时很少获得成功,那么会减少自旋次数。自旋次数的默认值是10次,可以使用参数-XX:PreBlockSpin来更改。

  再说一下为什么CAS在更新变量值的时候不会受到其他线程的影响呢?会不会我在判断更新值与预期值相等,进行更新的过程中,变量被其他线程更新了呢?其实不会,因为CAS具有排它性,一次CAS是一个原子操作,是CPU源语级别。确保隔离性。

  Java对于CAS是使用Unsafe类进行支持的。顾名思义,不安全,可以让程序员像C语言那样直接操纵内存指针。java.util.concurrent.atomic包下的类,都是使用CAS实现的。

ABA缺陷

  不知道大家通过上面对CAS的介绍说明,看到了CAS算法的缺陷没有!

  CAS本身会有ABA问题。举个例子,变量m = 10,我要把m更新为30。在我判断之前,有其他线程先把m更新到50,在从50更新到10。那么我进行 10 == 10的判断时,这时候我怎么确定m的值有没有被改过呢?这就是ABA问题了。

  要解决这个问题,我们就需要在进行 10 == 10判断的时候,还需要有其他参照。Java中有一个类AtomicStampedReference,这个类除了维护变量值之外,还会维护一个时间戳。用于确定数值版本。

private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

  用volatile关键字修饰的内部类。

  

  看一下核心的compareAndSet()方法:

public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

  可以看到除了比较数值之外,还会比较时间戳。

原文地址:https://www.cnblogs.com/sunshine-ground-poems/p/10306650.html

时间: 2024-10-10 08:08:01

CAS无锁策略的相关文章

面试必备:CAS无锁机制

CAS无锁机制原理,面试高频问题之一,其实,日常开发中并不会直接使用CAS无锁机制,都是通过一系列封装好的工具类来使用, 说不定面试官不提问,都不知道有这么个东西存在. 1.能说一下你对CAS的理解吗? 参考回答: 通常我们提到保证多线程安全,会想到三种方式,一是使用Synchronize关键字,但是有个问题就是,使用了Synchronize加锁后的多线程相当于串行,执行效率并不是太高,所以在高并发场景下,使用第二种方式Lock锁,Lock锁要比使用Synchronize关键字在性能上有极大的提

CAS 无锁队列

队列是常用的数据结构,采用的FIFO(first in firstout)原则,新元素(等待进入队列的元素)总是被插入到尾部,而读取的时候总是从头部开始读取.在计算中队列一般用来做排队(如线程池的等待排队,锁的等待排队),用来做解耦(生产者消费者模式),异步等等.在java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列.队列在现实生活中也很常见,例如去超市买东西排队付钱,先来的先付账走人回家,后来的要等前面的人付完钱才能付账. 首先我们看一段队列代码: type Queu

actomic cas无锁操作。

AtomicInteger中 维护了一个变量 volatile int value; AtomicLong中 维护了一个变量  volatile Long value; 这句unsafe.compareAndSwapInt(this, valueOffset, expect, update);等同这句 unsafe.compareAndSwapInt(value, expect, update);意思是 value等于expect 如果相同 则把value 值更新成update为什么是上面写法,

4.锁--无锁编程以及CAS

无锁编程以及CAS 无锁编程 / lock-free / 非堵塞同步 无锁编程,即不使用锁的情况下实现多线程之间的变量同步,也就是在没有线程被堵塞的情况下实现变量的同步,所以也叫非堵塞同步(Non-blocking Synchronization). 实现非堵塞同步的方案称为"无锁编程算法"( Non-blocking algorithm). lock-free是眼下最常见的无锁编程的实现级别(一共三种级别). 为什么要 Non-blocking sync ? 使用lock实现线程同步

CAS原子锁 高效自旋无锁的正确用法

1 #pragma once 2 #ifndef _atomic_lock_h_include_ 3 #define _atomic_lock_h_include_ 4 5 #include <windows.h> 6 7 #define cpu_pause() __asm {pause} 8 #define thread_yield() Yield() 9 10 #define spin_num (2048) 11 12 typedef struct { 13 volatile long l

非阻塞同步算法与CAS(Compare and Swap)无锁算法

CAS无锁算法 要实现无锁(lock-free)的非阻塞算法有多种实现方法,其中CAS(比较与交换,Compare and swap)是一种有名的无锁算法.CAS, CPU指令,在大多数处理器架构,包括IA32.Space中采用的都是CAS指令,CAS的语义是"我认为V的值应该为A,如果是,那么将V的值更新为B,否则不修改并告诉V的值实际为多少",CAS是项乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起

无锁编程以及CAS

无锁编程以及CAS 无锁编程 / lock-free / 非阻塞同步 无锁编程,即不使用锁的情况下实现多线程之间的变量同步,也就是在没有线程被阻塞的情况下实现变量的同步,所以也叫非阻塞同步(Non-blocking Synchronization). 实现非阻塞同步的方案称为"无锁编程算法"( Non-blocking algorithm). lock-free是目前最常见的无锁编程的实现级别(一共三种级别). 为什么要 Non-blocking sync ? 使用lock实现线程同步

无锁编程与有锁编程的性能对比与分析

最近维护的一个网络服务器遇到性能问题,于是就对原有的程序进行了较大的框架改动.改动最多的是线程工作模式与数据传递方式,最终的结果是改变锁的使用模式.经过一番改进,基本上可以做到 GMb 网卡全速工作处理.在 性能达标之后,一度在想有没有什么办法使用更加轻量级锁,或者去掉锁的使用,为此搜索一些相关的研究成果,并做了一些实验来验证这些成果,因而就有这篇文章.希望有做类似工作的同行可以有所借鉴.如果有人也有相关的经验,欢迎和我交流. 1 无锁编程概述 本节主要对文献 [1] 进行概括,做一些基础知识的

无锁的同步策略——CAS操作详解

1. 从乐观锁和悲观锁谈起 乐观锁和悲观锁是两种不同的解决并发问题的策略.悲观锁策略假定任何一次并发都会发生冲突,所以总是采用最严格的方式来进行并发控制.java中的独占锁(synchronized和重入锁)就是典型悲观锁实现,它只允许线程互斥的访问临界区,也就是阻塞式的同步方式.而乐观锁策略假定大部分情况下并发冲突不会发生,采用的是一种更为宽松的方式来进行并发控制.比如我们马上就要讲的CAS操作.它允许多线程非阻塞式地对共享资源进行修改,但同一时刻只有一个线程能够成功,其他线程被告知失败但并不