解密Java多线程中的锁机制:CAS与Synchronized的工作原理及优化策略

简介: 解密Java多线程中的锁机制:CAS与Synchronized的工作原理及优化策略

CAS

什么是CAS

CAS: 全称Compare and swap,字面意思:”比较并交换“,CAS涉及如下操作:

假设内存中的原数据为A,旧的预期值为B ,需要修改的值为C。

  1. 首先把A与B进行比较,看A与B是否相同。
  2. 如果A与B相同,则把数据C的值赋予A。
  3. 返回操作成功。

我们来写一个CAS的伪代码以帮忙我们更好理解CAS。

boolean Cas(int a,int b,int c){
        //进行比较看a是否发生变化
        if(a==b){
            a=c;
            return true;
        }
       return false;
    }

CAS是乐观锁的一种实现方式,当多个线程对一个数据进行操作时,只有一个线程操作成功,其他线程并不会阻塞,会返回操作失败的信号。

真实的 CAS 是一个原子的硬件指令完成的,只有硬件予以支持,软件方面才能实现。

CAS的应用

标准库中提供了 java.util.concurrent.atomic 包,里面的类都是基于这种方式来实现的。

典型的就是 AtomicInteger 类, 其中的 getAndIncrement 相当于 i++ 操作。

public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        AtomicInteger  seq = new AtomicInteger(0);
        //进行++操作
        seq.getAndIncrement();
        seq.getAndIncrement();
        seq.getAndIncrement();
        System.out.println(seq);
    }

我们点开自增方法,我们看到它的操作也是通过上述伪代码的那种方式实现的。

也可以使用CAS实现自旋锁

ABA问题

假设存在两个线程 t1 和 t2。 有一个共享变量 num, 初始值为 A。

接下来,线程 t1 想使用 CAS 把 num 值改成 Z,那么就需要

  • 先读取 num 的值, 记录到 oldNum 变量中。
  • 使用 CAS 判定当前 num 的值是否为 A, 如果为 A,就修改成 Z。
    但是,在 t1 执行这两个操作之间,t2 线程可能把 num 的值从 A 改成了 B, 又从 B 改成了 A。

异常举例

以银行取钱为例:

  1. 存款 100,线程1 获取到当前存款值为 100,期望更新为 50; 线程2 获取到当前存款值为 100, 期望更新为 50。
  2. 线程1 执行扣款成功, 存款被改成 50。线程2 阻塞等待中。
  3. 在线程2 执行之前, 你的朋友正好给你转账 50, 账户余额变成,100。
  4. 轮到线程2 执行了,发现当前存款为 100,和之前读到的 100 相同,再次执行扣款操作。

这样我们的钱就不翼而飞了,所以这种情况是万万不可的。

所以我们引入版本号来解决这个问题。CAS在读取旧值时也要读取版本号,在修改时,如果读到的版本号与当前版本号相同就进行修改,如果当前版本号高于读到的版本号,就修改失败。

Synchronized 原理

基本特征

  1. 开始时是乐观锁,如果锁冲突严重就升级为悲观锁。
  2. Synchronized是可重入锁。
  3. 是不公平锁。
  4. 是不可读写锁
  5. 开始是轻量级锁实现,如果锁被持有的时间较长, 就转换成重量级锁。

加锁过程

加锁流程图:

偏向锁

偏向锁就是在当前锁对象中标记改锁属于那个线程,没有进行实际加锁,能不加锁就不加锁,减少不必要的开销,只有当其他线程来竞争锁时,才会进行锁升级,由偏向锁变为轻量级锁。

轻量级锁

锁升级为轻量级锁之后,通过CAS实现。

  • 通过CAS检查并更新一块内存。
  • 如果更新成功,则认为加锁成功。
  • 如果更新失败,则认为加锁失败,锁被占用

重量级锁

如果竞争进一步激烈, 自旋不能快速获取到锁状态,就会膨胀为重量级锁

此处的重量级锁就是指用到内核提供的 mutex。

  • 执行加锁操作, 先进入内核态。
  • 在内核态判定当前锁是否已经被占用
  • 如果该锁没有占用, 则加锁成功,并切换回用户态。
  • 如果该锁被占用,则加锁失败。 此时线程进入锁的等待队列,挂起。 等待被操作系统唤醒。
  • 经历了一系列的沧海桑田, 这个锁被其他线程释放了, 操作系统也想起了这个挂起的线程, 于是唤醒这个线程, 尝试重新获取锁。

当多个线程竞争同一把锁,自旋等待的时间过长,无法获取到锁时,JVM会将这把锁升级为重量级锁。这时,线程并不再进行自旋等待,而是进入内核态,通过操作系统提供的mutex实现来管理锁的状态和等待队列。

在内核态中,操作系统判定当前锁是否已经被占用。如果锁没有被占用,则线程成功获取到锁,并切换回用户态继续执行。如果锁已经被占用,则线程加锁失败。此时,线程会进入锁的等待队列,并被操作系统挂起,等待被唤醒。

随着时间的推移和线程的竞争,当其他线程释放了这把锁并且操作系统意识到有线程在等待这个锁时,操作系统会唤醒等待的线程,使其重新启动并尝试重新获取锁。这个过程可能会经历一段时间,之后线程再次尝试获取锁以继续执行。

其他优化操作

锁消除

编译器+JVM 判断锁是否可消除,如果可以,就直接进行消除了。

也就是说我们许多加锁操作在单线程中运行时,那些加锁操作的锁就没必要。

@Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

例如 StringBuffe中的append操作就会涉及加锁操作,我们在单线程运行中就可以进行锁消除。

锁粗化

一段逻辑中如果出现多次加锁解锁,编译器 + JVM 会自动进行锁的粗化。

用我们上课讲的例子就是:

领导给下面人布置任务呢,一共三个任务,现在有这两种做法:

  1. 给员工打一个电话一次性什么三个任务。
  2. 给员工打三个电话,一次说一个任务。

让我们大家选择,大家肯定选择做法一啊,当然人家jvm也会进行这样的锁粗化。

可以用一个代码理解一下:

//频繁加锁
        for (int i = 0; i < 100; i++) {
            synchronized (o1){
            }
        }
        //粗化
        synchronized (o1){
            for (int i = 0; i < 100; i++) {
            }
        }

把锁粗化,避免频繁申请释放锁。


相关文章
|
3月前
|
人工智能 前端开发 安全
Java开发不可不知的秘密:类加载器实现机制
类加载器是Java中负责动态加载类到JVM的组件,理解其工作原理对开发复杂应用至关重要。本文详解类加载过程、双亲委派模型及常见类加载器,并介绍自定义类加载器的实现与应用场景。
186 4
|
5月前
|
人工智能 JavaScript Java
Java反射机制及原理
本文介绍了Java反射机制的基本概念、使用方法及其原理。反射在实际项目中比代理更常用,掌握它可以提升编程能力并理解框架设计原理。文章详细讲解了获取Class对象的四种方式:对象.getClass()、类.class、Class.forName()和类加载器.loadClass(),并分析了Class.forName()与ClassLoader的区别。此外,还探讨了通过Class对象进行实例化、获取方法和字段等操作的具体实现。最后从JVM类加载机制角度解析了Class对象的本质及其与类和实例的关系,帮助读者深入理解Java反射的工作原理。
104 0
|
5月前
|
人工智能 Java 关系型数据库
Java——SPI机制详解
SPI(Service Provider Interface)是JDK内置的服务提供发现机制,主要用于框架扩展和组件替换。通过在`META-INF/services/`目录下定义接口实现类文件,Java程序可利用`ServiceLoader`动态加载服务实现。SPI核心思想是解耦,允许不同厂商为同一接口提供多种实现,如`java.sql.Driver`的MySQL与PostgreSQL实现。然而,SPI存在缺陷:需遍历所有实现并实例化,可能造成资源浪费;获取实现类方式不够灵活;多线程使用时存在安全问题。尽管如此,SPI仍是Java生态系统中实现插件化和模块化设计的重要工具。
159 0
|
5月前
|
设计模式 人工智能 安全
AQS:Java 中悲观锁的底层实现机制
AQS(AbstractQueuedSynchronizer)是Java并发包中实现同步组件的基础工具,支持锁(如ReentrantLock、ReadWriteLock)和线程同步工具类(如CountDownLatch、Semaphore)等。Doug Lea设计AQS旨在抽象基础同步操作,简化同步组件构建。 使用AQS需实现`tryAcquire(int arg)`和`tryRelease(int arg)`方法以获取和释放资源,共享模式还需实现`tryAcquireShared(int arg)`和`tryReleaseShared(int arg)`。
252 32
AQS:Java 中悲观锁的底层实现机制
|
5月前
|
Java 区块链 网络架构
酷阿鲸森林农场:Java 区块链系统中的 P2P 区块同步与节点自动加入机制
本文介绍了基于 Java 的去中心化区块链电商系统设计与实现,重点探讨了 P2P 网络在酷阿鲸森林农场项目中的应用。通过节点自动发现、区块广播同步及链校验功能,系统实现了无需中心服务器的点对点网络架构。文章详细解析了核心代码逻辑,包括 P2P 服务端监听、客户端广播新区块及节点列表自动获取等环节,并提出了消息签名验证、WebSocket 替代 Socket 等优化方向。该系统不仅适用于农业电商,还可扩展至教育、物流等领域,构建可信数据链条。
|
安全 Java
Java多线程中的锁机制:深入解析synchronized与ReentrantLock
Java多线程中的锁机制:深入解析synchronized与ReentrantLock
213 0
|
Java
Java 锁机制 synchronized
转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/75126630 本文出自【赵彦军的博客】 1、前言 在多线程并发编程中Synchronized一直是元老级角色,很多人都会称呼它为重量级锁,但是随着Java SE1.6对Synchronized进行了各种优化之后,有些情况下它并不那么重了,本文详细介绍了Java SE1.6中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁,以及锁的存储结构和升级过程。
1391 0
|
17天前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
Java 数据库 Spring
54 0
|
1月前
|
算法 Java
Java多线程编程:实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
70 16