你深入了解过什么是CAS乐观锁吗

CAS、CAS自旋、CAS自旋锁、CLH锁与Java AQS:深入理解并发编程核心机制 CAS(Compare and Swap)是一种无锁(Lock-Free)的原子操作,用于在多线程环境下实现数据同步。CLH(Craig, Landin, Hagersten)锁是一种基于链表的队列锁,通过隐式队列管理线程,减少缓存一致性流量。基于CAS自旋实现的锁,线程在获取锁失败时不会阻塞,而是循环尝试。理解这些机制的原理与实现,是编写高效、健壮并发代码的关键。CAS自旋是指线程在CAS失败后循环重试,直到成功。)的核心框架,用于构建锁和同步器(如。AQS提供需子类实现的抽象方法(如。 阅读详情

1.乐观锁CAS和悲观锁synchronized

Compare and Swap,简称CAS,是一种通过乐观锁保证变量操作原子性的机制。

我们通常熟悉的加锁方式是通过synchronized关键字,可以很方便地给实例方法、静态方法和代码块加锁,保证操作的原子性。

synchronized锁是是悲观的,是同步锁,它假定更新很可能冲突,所以先获取锁,得到锁后才更新。

synchronized代表一种阻塞式算法,得不到锁的时候,进入锁等待队列,等待其他线程唤醒,有上下文切换开销。原子变量的更新逻辑是非阻塞式的,更新冲突的时候,它就重试,不会阻塞,不会有上下文切换开销。

与synchronized锁相比,CAS原子更新方式代表一种不同的思维方式。

悲观锁更新的思维方式认为,在更新数据的时候大概率会有其他线程去争夺共享资源,所以悲观锁的做法是,第一个获取资源的线程会将资源锁定起来,其他没争夺到资源的线程只能进入阻塞队列,等第一个获取资源的线程释放锁之后,这些线程才能有机会重新争夺资源。

synchronized就是java中悲观锁的典型实现,synchronized的优点是使用起来非常简单方便,但缺点是会使没争抢到资源的线程进入阻塞状态,线程在阻塞状态和Runnable状态之间切换效率较低(比较慢)。

在更新操作非常快的情况下,仍然用synchronized将其他线程都锁住,现场状态切换的成本就变得非常高,线程从Blocked状态切换回Runnable花费的时间可能比更新操作的时间还要长。

乐观锁更新的思维方式认为,在更新数据的时候其他线程争抢这个共享变量的概率非常小,所以更新数据的时候不会对共享数据加锁,但在正式更新数据之前会检查数据是否被其他线程改变过,如果未被其他线程改变过就将共享变量更新成最新值,如果发现共享变量已经被其他线程更新过了就重试,直到成功为止。CAS机制就是乐观锁的典型实现。在并发量不是很高的情况下,或者线程对共享资源的占用时间不是很长,由于避免了频繁切换线程状态,因此使用CAS机制的效率会比synchronized锁更高。

2.原子变量CAS原理

Java的原子变量内部就是通过CAS指令来实现的。

原子变量的更新逻辑是乐观的,它假定冲突比较少,但使用CAS更新,也就是进行冲突检测,如果确实冲突了,那也没关系,继续尝试就好了。

对于大部分比较简单的操作,无论是在低并发还是高并发情况下,这种乐观非阻塞方式的性能都远高于悲观阻塞式方式。

Java并发包中的基本原子变量类型有以下几种。

  • AtomicBoolean:原子Boolean类型,常用来在程序中表示一个标志位。

  • AtomicInteger:原子Integer类型。

  • AtomicLong:原子Long类型,常用来在程序中生成唯一序列号。

  • AtomicReference:原子引用类型,用来以原子方式更新复杂类型。

  • LongAdder、LongAccumulator、Double-Adder和DoubleAccumulator:Java 8增加,适合高并发统计汇总的场景。

原子变量相对比较简单,但对于复杂一些的数据结构和算法,非阻塞方式往往难于实现和理解,幸运的是,Java并发包中已经提供了一些非阻塞容器,我们只需要会使用就可以了,比如:

  • ConcurrentLinkedQueue和ConcurrentLinkedDeque:非阻塞并发队列。

  • ConcurrentSkipListMap和ConcurrentSkipListSet:非阻塞并发Map和Set。

  • AtomicLongArray、AtomicReferenceArray:如针对数组类型的类。

  • AtomicIntegerFieldUpdater、AtomicReferenceFieldUpdater:原子方式更新对象中的字段。

AtomicInteger包含一些以原子方式实现组合操作的方法,部分方法如下:

//以原子方式获取旧值并设置新值
public final int getAndSet(int newValue) 

//以原子方式获取旧值并给当前值加1
public final int getAndIncrement()

//以原子方式获取旧值并给当前值减1
public final int getAndDecrement()

//以原子方式获取旧值并给当前值加delta
public final int getAndAdd(int delta)

//以原子方式给当前值加1并获取新值
public final int incrementAndGet()

//以原子方式给当前值减1并获取新值
public final int decrementAndGet()

//以原子方式给当前值加delta并获取新值public final int
addAndGet(int delta)

//compareAndSet是一个非常重要的方法,比较并设置,我们以后将简称为CAS。
//该方法有两个参数expect和update,以原子方式实现了如下功能:
// 如果当前值等于expect,则更新为update,否则不更新,
// 如果更新成功,返回true,否则返回false。
public final boolean compareAndSet(int expect, int update)
复制代码

以incrementAndGet方法为例,代码主体是个死循环,先获取当前值current,计算期望的值next,然后调用CAS方法进行更新,如果更新没有成功,说明value被别的线程改了,则再去取最新值并尝试更新直到成功为止。源码如下:

public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if(compareAndSet(current, next)){
            return next;
        }
    }
}
复制代码

synchronized是悲观的,它假定更新很可能冲突,所以先获取锁,得到锁后才更新。

原子变量的更新逻辑是乐观的,它假定冲突比较少,但使用CAS更新,也就是进行冲突检测,如果确实冲突了,那也没关系,继续尝试就好了。

synchronized代表一种阻塞式算法,得不到锁的时候,进入锁等待队列,等待其他线程唤醒,有上下文切换开销。

原子变量的更新逻辑是非阻塞式的,更新冲突的时候,它就重试,不会阻塞,不会有上下文切换开销。对于大部分比较简单的操作,无论是在低并发还是高并发情况下,这种乐观非阻塞方式的性能都远高于悲观阻塞式方式。

原子变量相对比较简单,但对于复杂一些的数据结构和算法,非阻塞方式往往难于实现和理解,幸运的是,Java并发包中已经提供了一些非阻塞容器,我们只需要会使用就可以了,比如:

ConcurrentLinkedQueue和ConcurrentLinkedDeque:非阻塞并发队列。 ConcurrentSkipListMap和ConcurrentSkipListSet:非阻塞并发Map和Set。

compareAndSet是怎么实现的呢?我们看代码:

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
复制代码

它调用了unsafe的compareAndSwapInt方法。

unsafe是什么呢?它的类型为sun.misc.Unsafe,定义为:

private static final Unsafe unsafe = Unsafe.getUnsafe();
复制代码

它是Sun的私有实现,从名字看,表示的也是“不安全”,一般应用程序不应该直接使用。

原理上,一般的计算机系统都在硬件层次上直接支持CAS指令,而Java的实现都会利用这些特殊指令。

从程序的角度看,可以将compareAndSet视为计算机的基本操作,直接接纳就好。

基于CAS,除了可以实现乐观非阻塞算法之外,还可以实现悲观阻塞式算法,比如锁。

实际上,Java并发包中的所有阻塞式工具、容器、算法也都是基于CAS的(不过,也需要一些别的支持)。用AtomicInteger实现一个锁MyLock:

public class MyLock {
    private Atomicinteger status = new AtomicInteger(0);
    public void lock() {
        while(!status.compareAndSet(0, 1)) {
            Thread.yield();
        }
    }
    public void unlock() {
        status.compareAndSet(1, 0);
    }
}
复制代码

在MyLock中,使用status表示锁的状态,0表示未锁定,1表示锁定,lock()、unlock()使用CAS方法更新,lock()只有在更新成功后才退出,实现了阻塞的效果,不过一般而言,这种阻塞方式过于消耗CPU,MyLock只是用于演示基本概念,实际开发中应该使用Java并发包中的类,如ReentrantLock。

3.CAS的问题与解决

CAS比悲观锁的效率高,从阻塞机制变成了非阻塞机制,减少了线程之间等待的时间,有一个前提,就是并发量不大。

因为在线程之间竞争程度大的时候,如果使用CAS,每次都有很多的线程在竞争,也就是说CAS机制不能更新成功。这种情况下CAS机制会一直重试,这样就会比较耗费CPU。

因此可以看出,如果线程之间竞争程度小,使用CAS是一个很好的选择;但是如果竞争很大,使用锁可能是个更好的选择。

在并发量非常高的环境中,如果仍然想通过原子类来更新的话,可以使用AtomicLong的替代类:LongAdder。

除了在高并发场景下耗费CPU的问题,使用CAS方式更新还有一个ABA问题。

该问题是指,假设当前值为A,如果另一个线程先将A修改成B,再修改回成A,当前线程的CAS操作无法分辨当前值发生过变化。

ABA是不是一个问题与程序的逻辑有关,即B之前的A和B之后的A不影响程序逻辑,ABA也就不是问题。

而如果确实有问题,解决方法是使用AtomicStampedReference,在修改值的同时附加一个时间戳,只有值和时间戳都相同才进行修改,其CAS方法声明为:

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)));
}
复制代码

AtomicStampedReference在compareAndSet中要同时修改两个值:一个是引用,另一个是时间戳。

它怎么实现原子性呢?实际上,内部AtomicStampedReference会将两个值组合为一个对象,修改的是一个值,我们看代码:

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)));
}
复制代码

这个Pair是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);    
}
}
复制代码

AtomicStampedReference将对引用值和时间戳的组合比较和修改转换为了对这个内部类Pair单个值的比较和修改。

对于并发环境中的计数、产生序列号等需求,应该使用原子变量而非锁,CAS是Java并发包的基础,基于它可以实现高效的、乐观、非阻塞式数据结构和算法,它也是并发包中锁、同步工具和各种容器的基础。

Java锁之乐观锁、悲观锁(包括CAS操作、synchronized底层实现原理) 文章目录锁分类乐观锁 / 悲观锁乐观锁的实现:CAS(Compare and Swap)操作CAS存在的问题ABA问题解决方案独享锁 / 共享锁互斥锁 / 读写锁可重入锁公平锁 / 非公平锁分段锁偏向锁 / 轻量级锁 / 重量级锁 锁分类         Java中对锁的分类有如下几种:            &nbsp 阅读详情

相关推荐

深入理解CAS (自旋锁)

CAS,compareandswap的缩写,中文翻译为比较并交换。CAS操作中包含三个操作数——内存位置(V)、预期原值(E)和新值(N)。这三个字母缩写的含义Variable变量;Expect预期;New新如果内存位置的值与预期原值相匹配,那么处理器会⾃动将该位置值更新为新值。否则,处理器不做任何操作。⽆论哪种情况,它都会在CAS指令之前返回该位置的值(在CAS的⼀些特殊情况下将仅返回CAS是否成功,而不提取当前值)。CAS用同步的方式。...

流楚丶格念的博客 5993

「JUC并发编程」初识CAS锁(概述、底层原理、原子引用、自旋锁、缺点)

CAS的全称为,直译就是对比交换。是一条CPU的原子指令,其作用是让CPU先进行比较两个值是否相等,然后原子地更新某个位置的值。经过调查发现,其实现方式是基于硬件平台的汇编指令,就是说CAS是靠硬件实现的,JVM只是封装了汇编调用,那些AtomicInteger类便是使用了这些封装后的接口。简单解释:CAS操作需要输入两个数值,一个旧值(期望操作前的值)和一个新值,在操作期间先比较下在旧值有没有发生变化,如果没有发生变化,才交换成新值,发生了变化则不交换。...

frozenpenguin的博客 7426

超越并发瓶颈:CAS与乐观锁的智慧应用

synchronized 是 Java 内置的同步机制,依赖 JVM 实现,通过进入和退出监视器锁(Monitor Lock)来保证线程的安全性。在高并发情况下,线程可能会频繁地在 BLOCKED 状态和 RUNNABLE 状态之间切换,导致用户态和内核态的频繁切换,从而影响性能。 CAS和乐观锁作为两种重要的并发控制机制备受关注。CAS机制直接利用硬件保证原子性,而乐观锁则基于乐观的思想进行并发控制。本文将学习这两种机制的原理、应用及性能特点来进行体会

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 6万+

CAS锁机制(无锁、自旋锁、乐观锁、轻量级锁)

CAS锁机制(无锁、自旋锁、乐观锁、轻量级锁)

user2025的博客 2万+

利用featureCounts实现高效转录本定量:从比对到下游分析

本文详细介绍了利用featureCounts工具进行RNA-seq转录本定量的完整流程。从软件安装、输入文件准备,到核心命令参数解析与批量样本处理,再到将生成的计数矩阵无缝衔接至DESeq2进行差异表达分析,提供了从比对到下游分析的一站式实战指南。文章重点阐述了featureCounts在效率与易用性上的优势,并分享了常见问题排查与性能优化技巧,帮助研究者高效完成转录本定量这一关键步骤。

weixin_29069131的博客 320

Android 13 录音APK在后台无数据的处理

未获取到录音数据

chenchen4310的博客 1185

悲观锁,乐观锁,CAS初步了解

从零开始 互斥锁(悲观锁) 如果多个线程想要操作一个资源。我们使用互斥锁进行资源同步,但是互斥锁的同步方式是悲观的: 简单来说,就是系统会悲观的认为,如果我们不严格同步线程调用,那么一定会产生线程资源异常。 所以互斥锁将会把资源锁定,在一个线程访问此资源时阻塞其他线程,以此来达到多线程资源同步。 那么问题在于?这样虽然能保证多线程资源安全,但是如果多线程只是进行读的操作,那么这样会进行大量的线程切换,耗时严重。 甚至有些时候,哪怕是专门进行线程同步,也比线程切换耗费时间少。 CAS 那么我们可以想屁吃,

m0_62888305的博客 1131

codesys工程ST语言学习笔记(二)写文件操作与添加库方法

ST语言文件读写功能 由于实验中需要大量的数据,文件读写比较方便,但是网上的文件读写的程序很多都用不了,小编将自己的工程发布出来

sf9090的博客 1万+

乐观锁悲观锁CAS锁自旋锁你了解吗?

文章目录一,概念,使用场景1. 乐观锁2. 悲观锁3. 适用场景二,实现方式1. 版本号机制2. CAS锁3. 乐观锁的缺点1)ABA问题2)循环时间长开销大3)只能保证一个共享变量的原子操作 一,概念,使用场景 1. 乐观锁 总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。 乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提

ifwecande的博客 750

SAR学习笔记后续-phased工具箱介绍

摘要:相控阵雷达介绍,基于仿真对MATLAB中phased工具箱进行了详细介绍

yjh_2019的博客 1万+

「0基础安装本地Hermes」本地部署Hermes|为Hermes装上UI图形界面

Hermes已经发布有一段时间了,不少小伙伴也装配上了这个Agent。相对于之前发布爆火的Openclaw,Hermes对于很多小白不是很友好,它没有属于自己的UI界面,只能在本地终端运行,前不久Github上有人发布自己的作品,让终端里的Hermes拥有属于自己的UI界面,EKKOLearnAI开发的Hermes UI界面项目为终端运行的Hermes提供了可视化操作方式,降低了使用门槛。该项目通过Web界面与本地Hermes Agent交互,实现更友好的操作体验。

qq_55438365的博客 1878

面试官:你了解乐观锁和悲观锁吗?CAS 是如何实现?

‌乐观锁和悲观锁是并发控制的一种机制,用于多线程或多进程环境下对共享资源的访问管理,以防止数据不一致或竞态条件‌。

小斜同学的博客 1323

施耐德EcoStruxure平台深度体验:IEC 61499在智慧物流中心的真实应用案例解析

本文深度解析施耐德EcoStruxure平台在智慧物流中心的应用,重点探讨IEC 61499标准如何通过分布式控制和功能块技术重构自动化逻辑。通过上海某物流中心的真实案例,展示了该平台在提升系统弹性、降低停机成本方面的显著成效,为工业自动化转型提供实践参考。

weixin_30576827的博客 66

重新认识CAS 跟 AQS 你了解乐观锁和悲观锁吗?

前前言 https://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247484070&idx=1&sn=c1d49bce3c9da7fcc7e057d858e21d69&chksm=fba6eaa5ccd163b3a935303f10a54a38f15f3c8364c7c1d489f0b1aa1b2ef...

weixin_30919571的博客 214

Python库CloudScraper详细使用(绕过 Cloudflare 的反机器人页面的 Python 模块)

CloudScraper是一个专门用于绕过Cloudflare反机器人保护的Python库,它基于requests库构建,能够处理Cloudflare的5秒盾、WAF和人机验证等防护机制。

数据知道的博客 1万+

银河麒麟高级服务器V11操作系统安装部署zabbix监控平台的实操保姆级教程

本文详细介绍了在《银河麒麟高级服务器V11上安部署Zabbix监控系统的全过程》涵盖了zabbix监控系统涉及到的所有软件安装、参数优化、服务启动验证及防火墙配置等一系列实操。其中关于安装过程报错undefined symbol: usmAES256CiscoPrivProtocol;ares_reinit等依赖库问题进行了详细记录与分析解决;还提供了Web前端中文显示修复方案和Admin密码修改方法。实现监控平台的100%部署上线,实现对业务系统的实时监控,保证业务的稳定运行。

提供C#相关开发 、云计算、运维测试、网络安全相关技术分享与服务,有意向可联系。 533

Java:CAS(乐观锁)

https://www.jianshu.com/p/ae25eb3cfb5d

weixin_40010498的博客 158

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

悲观锁、乐观锁、CAS及ABA问 题

悲观锁【Pessimistic Lock】:具有强烈的独占和排他特性 每次拿数据都认为别人会修改,所以每次拿数据都会上锁,这样别人想拿这个数据就会block知道它拿到锁,传统的关系型数据库用到很多这种锁机制,行锁、表锁,读锁,写锁等,都是在做操作之前先上锁,它指的是对数据被外界【包括本系统当前事务,以及来自外部系统的事务处理】修改持保守态度,因此在整个数据处理过程中,将数据处于锁定状态, 共享资源每次都只给一个线程使用,其他线程阻塞,用完后再把资源转让给其他线程 java中的synchronized和R..

g_l_xz的博客 431

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

CAS:乐观锁原理

https://www.jianshu.com/p/ae25eb3cfb5d

qq_38677458的博客 128

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

JUC并发编程——CAS 介绍及底层源码分析

文章目录JUC并发编程——CAS 介绍及底层源码分析1、什么是 CAS2、JDK 对 CAS 的支持3、原子类操作源码分析4、原子引用解决ABA问题 JUC并发编程——CAS 介绍及底层源码分析 1、什么是 CAS 前言:使用锁的代价 Java并发处理中锁非常重要,但是使用锁会带来下面几个问题: 加锁、释放锁会需要操作系统进行上下文切换和调度延时,在上下文切换的时候,cpu之前缓存的指令和数据都将失效,这个过程将增加系统开销。 多个线程同时竞争锁,锁竞争机制本身需要消耗系统资源。没有获取到锁的线程会被

万里顾一程的博客 702

cas修改数据源之后404_java并发编程中的CAS机制,你理解嘛?

学习Java并发编程,CAS机制都是一个不得不掌握的知识点。这篇文章主要是从出现的原因再到原理进行一个解析。希望对你有所帮助。一、为什么需要CAS机制?为什么需要CAS机制呢?我们先从一个错误现象谈起。我们经常使用volatile关键字修饰某一个变量,表明这个变量是全局共享的一个变量,同时具有了可见性和有序性。但是却没有原子性。比如说一个常见的操作a++。这个操作其实可以细分成三个步骤:(1)从内...

weixin_34506795的博客 223

比较并交换(CAS)

悲观锁:使用synchronized是独占锁,即悲观锁,会导致其他需要锁的被挂起,等待持有锁的线程释放锁 乐观锁:每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败则重试,直到成功为止 CAS(Compare And Swap):比较并替换 java.util.concurrent包(简称JUC)就是建立在CAS上的,例如其中的AtomicInteger类, 其中的一些方法底层便使用了CAS方法 在Unsafe类中提供了native方法,用于完成硬件级别的原子性操作,所以速度很快 另外,看到一

m0_46448741的博客 221

乐观锁与悲观锁

乐观锁与悲观锁 乐观锁: 假设都是最好的情况,每次拿数据都认为别人不会修改。但是在更新操作时会判断在此期间要更新的此条数据有没有被修改。使用场景:多读的类型,可提高吞吐量。 主要实现方式:版本号机制、CAS算法 版本号机制: 数据库表中加version字段,每次修改version+1。线程1更新数据时,会先读取要更新的数据值和此version字段,在提交更新操作时会将version字段+1(a),和新要更新的数据值一起更新的数据库,但是在提交更新操作这个动作之前会将当前数据库的version值(b)和目前a

hl404的博客 171

深度讲解CAS,面试实践必备

CAS是的缩写,直译就是比较并交换。CAS是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令,这个指令会对内存中的共享数据做原子的读写操作。其作用是让CPU比较内存中某个值是否和预期的值相同,如果相同则将这个值更新为新值,不相同则不做更新。本质上来讲CAS是一种无锁的解决方案,也是一种基于乐观锁的操作,可以保证在多线程并发中保障共享资源的原子性操作,相对于synchronized或Lock来说,是一种轻量级的实现方案。C/C++...

weixin_45985053的博客 263

悲观锁、乐观锁、自旋锁

18)悲观锁、乐观锁、自旋锁 (1)乐观锁 乐观锁是一种乐观的思想,即认为读多写少,遇到并发的可能性低,每次拿数据时都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用 版本号机制 和 CAS 算法实现。 Java 中的乐观锁基本都是通过 CAS 操作实现的,CAS 是一种更新的原子操作,比较当前值跟传入值是否一样,一样则更新,否则失败。 –>缺点: ABA问题: CAS 会导致 “ABA 问题”。CAS 算法实现的一个重要前提是需要取出内存中某时

zxiaohaha的博客 299

乐观锁CAS

在CAS中有三个值:V:要更新的变量(var)E:预期值(expected)N:新值(new)

m0_37636269的博客 1287
上一篇: 数据库优化完爆90%性能毛病的八大通用绝招
下一篇: 15个高并发系统设计锦囊,建立并发思维!
Java_LingFeng
博客等级 码龄4年 505粉丝 259原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值