关于java中的CAS(乐观锁)的一些基本知识

最新推荐文章于 2024-08-03 23:33:07 发布
原创 最新推荐文章于 2024-08-03 23:33:07 发布 · 165 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程

本文详细介绍了CAS(Compare and Swap)非阻塞算法的工作原理及其在并发控制中的应用。CAS由CPU硬件实现，执行速度快，通过比较内存地址处的期望值与实际值来决定是否更新值，是实现原子操作的基础。

CAS（非阻塞算法），CAS是由CPU硬件实现，所以执行相当快.CAS有三个操作参数：内存地址，期望值，要修改的新值，当期望值和内存当中的值进行比较不相等的时候，表示内存中的值已经被别线程改动过，这时候失败返回，当相等的时候，将内存中的值改为新的值，并返回成功。

超越并发瓶颈：CAS与乐观锁的智慧应用
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
04-25 5万+
synchronized 是 Java 内置的同步机制，依赖 JVM 实现，通过进入和退出监视器锁（Monitor Lock）来保证线程的安全性。在高并发情况下，线程可能会频繁地在 BLOCKED 状态和 RUNNABLE 状态之间切换，导致用户态和内核态的频繁切换，从而影响性能。 CAS和乐观锁作为两种重要的并发控制机制备受关注。CAS机制直接利用硬件保证原子性，而乐观锁则基于乐观的思想进行并发控制。本文将学习这两种机制的原理、应用及性能特点来进行体会
锁的艺术：Java并发中的常用锁策略与实践
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 170万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
乐观锁与悲观锁相关知识
haoshaoxing的专栏
10-15 226
内容来自：https://www.toutiao.com/a6579186676071924227/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&timestamp=1539572340&app=news_article&utm_source=weixin&iid=45822909...
乐观锁和悲观锁 :知识总结（一）
老码不识途的博客
09-03 400
    乐观锁:            相对比较乐观，进行更新的时候，并不会刻意的上锁，只会对该字段进行一个判断，判断是否修改过。可能会导致更新失败         使用场合：                     秒杀、比较适合读取操作比较频繁的场景          案例：                  实现乐观锁的两种方式：利用版本号或者时间戳 UPDATE TABLE...
我对乐观锁CAS的知识回顾
weixin_44339676的博客
02-06 130
乐观锁 每当提起乐观锁，都会被提起CAS。对于乐观锁，是系统一种比较乐观的状态，认为线程中运行时大概率不会产生资源竞争的情况，因此不会运行的时候就开始获取锁，只有等到有资源竞争的时候才会获取锁，Java中一般通过CAS机制来解决。 书面上的话：比较并交换（Compare And Swap），主要是为了解决原子性问题，同时又不想利用重量级的锁。通俗的话说：如果想更新一个值，想看看该值是否等于某个值，如果等于则更新该值。 我可以简单举一个例子： CAS主要是为了解决原子性问题，CAS为什么可以保证原子性呢？
CAS（乐观锁）
xxy55895的博客
05-05 339
CAS算法即是：Compare And Swap,比较并且替换 CAS算法存在着三个参数，内存值V，旧的预期值A，以及要更新的值B。当且仅当内存值V和预期值B相等的时候，才会将内存值修改为B，否则什么也不做，直接返回false; 比如说某一个线程要修改某个字段的值，当这个值初始化的时候会在内存中完成，根据Java内存模型，该线程保存着这个变量的一个副本；当且仅当这个变量的副本和内存的值如果相同，那...
lock是乐观锁吗_Java性能 -- CAS乐观锁
weixin_36362326的博客
11-25 850
synchronized / Lock / CASsynchronized和Lock实现的同步锁机制，都属于悲观锁，而CAS属于乐观锁悲观锁在高并发的场景下，激烈的锁竞争会造成线程阻塞，而大量阻塞线程会导致系统的上下文切换，增加系统的性能开销乐观锁乐观锁：在操作共享资源时，总是抱着乐观的态度进行，认为自己能够完成操作但实际上，当多个线程同时操作一个共享资源时，只有一个线程会成功，失败的线程不会被挂...
聊一聊Java中的悲观锁和乐观锁
做一个有思想的技术人
04-11 1621
聊一聊Java中的悲观锁和乐观锁
Java中高级核心知识全面解析——乐观锁与悲观锁（何谓悲观锁与乐观锁？乐观锁的两种实现方式以及缺点、CAS算法(1)
ghfgjfg679的博客
05-10 1063
面试建议是，
Java 并发编程：Java 中的乐观锁与 CAS
栗筝i的博客
08-03 2540
CAS，即 “比较并交换”（Compare-And-Swap），是一种用于解决多线程并行情况下性能损耗问题的机制。CAS 操作是一种乐观锁实现，广泛应用于包中的并发类。高效：CAS 是无锁操作，避免了传统锁机制带来的线程切换和上下文切换的开销；无死锁：由于没有使用锁，因此不会出现死锁问题。CAS 的缺点：忙等待：在高并发情况下，CAS 操作可能会不断重试，导致 CPU 资源浪费。
Java锁之乐观锁、悲观锁(包括CAS操作、synchronized底层实现原理)
Colorful_X的博客
05-20 728
文章目录锁分类乐观锁 / 悲观锁乐观锁的实现：CAS(Compare and Swap)操作CAS存在的问题ABA问题解决方案独享锁 / 共享锁互斥锁 / 读写锁可重入锁公平锁 / 非公平锁分段锁偏向锁 / 轻量级锁 / 重量级锁 锁分类         Java中对锁的分类有如下几种：            &nbsp
乐观锁与悲观锁
Fzxey的博客
08-08 256
文章目录前言乐观锁乐观锁实现方式悲观锁 前言 想知道乐观锁和悲观锁，先明白锁的概念；在程序出现并发访问时，会给资源加锁，以保证有序的访问资源，让拿到锁所有权的线程来操作资源，没有拿到的只有等待锁的所有权放开。这种锁就是为了保证资源的有序访问或者互斥访问。 我们根据看待并发的同步态度，可以将锁分为乐观锁和悲观锁。 乐观锁 顾名思义，就是对待同步的态度很乐观，认为并发访问时对同一数据的操作是不会...
悲观锁、乐观锁
GoodLuck_yujian的博客
05-04 237
       悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在...
Java中实现线程阻塞的方法
bluewaveandy的博客
06-23 2666
Java中实现线程阻塞的方法线程睡眠：Thread.sleep (long millis)线程等待：Object类中的wait()方法线程礼让，Thread.yield() 方法线程自闭，join()方法 线程睡眠：Thread.sleep (long millis) 使线程转到阻塞状态。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。 线程等待：Object类中的wait()方法 导致当前的线程等待，直到其他线程调用此对象的 notify() 唤醒方法。wait() 使得线程
JAVA线程池的初始化方法
bluewaveandy的博客
06-24 2250
Executors.newCachedThreadPool() //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。 Executors.newSingleThreadExecutor() //创建容量为1的缓冲池 newSingleTh
Web事件监听器接口
bluewaveandy的博客
08-05 456
Web应用生命周期 ServletContextListener 监听 ServletContext 对象的生命周期，就是监听 Web 应用的生命周期。当Servlet 容器启动或终止Web 应用时，会触发ServletContextEvent 事件，该事件由ServletContextListener 来处理。 在 ServletContextListener 接口中定义了处理ServletContextEvent 事件的两个方法。 /** * 当Servlet 容器启动Web 应用时调用该方法。在调用
ScheduledExecutorService：Timer替代器
bluewaveandy的博客
06-24 442
使用ScheduledExecutorService来替代Timer主要原因 1、Timer不支持多线程。全部挂在Timer下的任务都是单线程的，任务仅仅能串行运行。假设当中一个任务运行时间过长，会影响到其它任务的运行 2、Timer的线程不捕获异常。TimerTask假设抛出异常，那么Timer唯一的线程就会挂掉，这样挂在Timer下的全部任务都会无法继续运行。 ...
NIO的主要对象Buffer、Channel、Selector
bluewaveandy的博客
07-02 361
Buffer Buffer是一个对象，包含一些要写入或者读出的数据。 在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，也是写入到缓冲区中。任何时候访问NIO中的数据，都是通过缓冲区进行操作。缓冲区实际上是一个数组，并提供了对数据结构化访问以及维护读写位置等信息。具体的缓存区有这些：ByteBuffe、CharBuffer、 ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。他们实现了相同的接口：B
java中的一些线程安全对象
bluewaveandy的博客
06-24 275
ConcurrentHashMap ConcurrentHashMap相比于Hashtable在线程安全的基础上提供了更好的写并发能力，但同时降低了对读一致性的要求。 ConcurrentLinkedHashMap atomicinteger ---源码 public final long getAndIncrement() { while (true) { long current = get(); long next = current + 1; //当+1操作成功的时候直接
java的原子类中时默认使用了cas乐观锁吗？
最新发布
03-21
<think>嗯，用户问的是Java的原子类是否默认使用了CAS乐观锁。首先，我需要确认自己对Java原子类的理解是否正确。记得Java的并发包java.util.concurrent.atomic里有很多原子类，比如AtomicInteger、AtomicLong、AtomicReference等等。这些类的作用是提供原子操作，避免多线程下的竞态条件。 然后，CAS是Compare and Swap的缩写，是一种无锁算法。乐观锁的一种实现方式就是CAS，因为它假设操作时不会发生冲突，所以直接尝试更新，如果失败就重试。而悲观锁，比如synchronized，是假设会冲突，先加锁再操作。 原子类的实现是否用了CAS呢？根据之前学过的知识，是的，它们的内部通常依赖于Unsafe类提供的CAS操作。比如AtomicInteger的incrementAndGet()方法，应该就是通过循环CAS来更新值，直到成功为止。 不过，可能需要具体例子来验证。比如查看AtomicInteger的源码，发现它的方法比如compareAndSet、getAndIncrement等，底层调用了Unsafe的compareAndSwapInt方法，这就是CAS操作。这说明原子类确实使用了CAS作为实现机制。 但用户提到的是“默认使用”，那是否所有原子类的方法都是基于CAS？比如，像AtomicInteger的set方法可能直接赋值，而不需要CAS，因为set操作本身可能不需要原子性，或者使用volatile的写保证可见性。但像递增这种复合操作就必须用CAS。 另外，是否所有原子类都是基于CAS？比如AtomicBoolean、AtomicReference这些，应该也是同样的机制。而像AtomicStampedReference还用了版本号来解决ABA问题，但底层还是CAS。 所以，结论应该是Java的原子类确实默认使用CAS乐观锁来实现线程安全，尤其是在执行复合操作的时候。但像简单的set可能用volatile写，但整体来说，原子类的核心机制是CAS。</think>是的，Java中的原子类（位于`java.util.concurrent.atomic`包中）**默认基于CAS（Compare-and-Swap，比较并交换）乐观锁机制**实现线程安全。以下是逐步分析： --- ### 1. **原子类的核心设计** Java原子类（如`AtomicInteger`、`AtomicLong`、`AtomicReference`等）的目标是提供**无锁且线程安全**的操作。它们的底层实现依赖于： - **CAS指令**：通过CPU硬件级别的原子操作保证线程安全。 - **volatile变量**：确保内存可见性（修改后的值对其他线程立即可见）。 --- ### 2. **CAS如何工作** CAS是一个乐观锁机制，其核心逻辑为： ```java boolean compareAndSwap(expectedValue, newValue) { if (当前值 == expectedValue) { 更新为newValue; return true; } else { return false; } } ``` - **无需加锁**：线程直接尝试修改值，若失败则重试（自旋）。 - **硬件支持**：通过CPU指令（如x86的`CMPXCHG`）实现原子性。 --- ### 3. **源码验证（以AtomicInteger为例）** 以`AtomicInteger`的`incrementAndGet()`方法为例： ```java public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } ``` 底层调用`Unsafe`类的`getAndAddInt`方法： ```java public final int getAndAddInt(Object o, long offset, int delta) { int v; do { v = getIntVolatile(o, offset); // 读取当前值 } while (!compareAndSwapInt(o, offset, v, v + delta)); // CAS重试 return v; } ``` - **自旋循环**：不断尝试CAS直到成功。 - **直接操作内存**：通过`Unsafe`类绕过Java内存模型（JVM内部使用）。 --- ### 4. **CAS的优缺点** - **优点**： - **无锁**：避免线程阻塞，适合低竞争场景。 - **高性能**：减少上下文切换和锁开销。 - **缺点**： - **ABA问题**：可通过`AtomicStampedReference`（带版本号）解决。 - **高竞争下的自旋开销**：可能导致CPU资源浪费。 --- ### 5. **原子类的其他实现** 虽然CAS是原子类的默认机制，但某些场景会结合其他优化： - **LongAdder**：在高并发写入时，采用分段CAS（Cell分散竞争），减少冲突。 - **LazySet**：延迟更新值（仅最终一致，非实时可见）。 --- ### 总结 Java原子类默认通过**CAS乐观锁**实现线程安全，其核心是： 1. 依赖硬件指令保证原子性。 2. 自旋重试机制处理竞争。 3. 结合`volatile`保证可见性。 对于需要高性能且线程安全的计数器、状态标志等场景，原子类是理想选择。但在高竞争环境下，需根据实际需求选择`LongAdder`或显式锁。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值