【JavaEE】常见的锁策略、CAS、synchronized优化过程

最新推荐文章于 2024-08-20 11:05:12 发布
最新推荐文章于 2024-08-20 11:05:12 发布
阅读量431 收藏
点赞数 1
分类专栏： JUC JavaEE 文章标签： java-ee java 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62589078/article/details/130039915
版权
JavaEE 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
JUC
3 篇文章 0 订阅
订阅专栏

1.常见的锁策略

1.1乐观锁和悲观锁

乐观锁
乐观锁总是认为不会发生并发冲突，所以并不会上锁，只有在更新内存中的数据的时候，才会判断数据是否被修改过(底层使用版本号和CAS实现)。

悲观锁
悲观锁总是认为会发生并发冲突，内存中的数据会被修改，所以每次拿数据的时候都会上锁。

一般来说乐观锁做的事比较少，悲观锁做的事比较多。

就拿疫情举例：
小明认为接下来的疫情没那么严重，小红认为接下来的疫情会比较严重。
在这里插入图片描述
小明直接躺平:
在这里插入图片描述
小红去药店买了许多药，去超时买了很多吃的。
在这里插入图片描述

1.2轻量级锁和重量级锁

轻量级锁，加锁、解锁的过程比较快，比较高效。
重量级锁，加锁、解锁的过程比较慢，比较低效。
轻量级锁比较不依赖于操作系统内核，重量级锁比较依赖操作系统内核，所以会比较慢。

1.3自旋锁和挂起等待锁

自旋锁是轻量级锁的典型实现，挂起等待锁是重量级锁的典型实现。

自旋锁
自旋锁被一个线程占有的时候，其他的线程会不断地继续尝试拿锁🔒，不会涉及到内核态操作，纯属用户态操作，一旦锁被释放，可以立马拿到锁。
自旋锁加锁和解锁的过程比较快。

挂起等待锁
挂起等待锁被一个线程占有的时候，其他的线程不会继续尝试拿锁🔒，而是直接挂起等待，等到锁被释放了，其他线程被唤醒了，才继续竞争锁。
因为这个挂起等待操作涉及到操作系统内核，所以会比较慢。
挂起等待锁加锁和解锁的过程比较慢。

1.4互斥锁和读写锁

互斥锁
单纯的加锁和解锁操作，即进入代码块加锁，出了代码块解锁，synchronized就是互斥锁。

读写锁
读写锁分为读锁和写锁。分为为读加锁和读解锁、写加锁和写解锁。

  • 读锁和读锁之间是不互斥的
  • 读写和写锁之间是互斥的
  • 写锁和写锁之间是互斥的

java标准库提供了ReentrantReadWriteLock 类，实现了读写锁。
ReentrantReadWriteLock.ReadLock是一个读锁类，提供了lock()和unlock()方法
ReentrantReadWriteLock.WriteLock是一个写锁类，也提供了lock()和unlock()方法

读锁和读锁之间不互斥测试：

public class ReadWriteLockTest1 {
    public static void main(String[] args) {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock1 = rwLock.readLock();
        ReentrantReadWriteLock.ReadLock readLock2 = rwLock.readLock();


        Thread t1 = new Thread(()->{
            readLock1.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("读加锁 1");
            }
            readLock1.unlock();
        });

        Thread t2 = new Thread(()->{
            readLock2.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("读加锁 2");
            }
            readLock2.unlock();
        });

        t1.start();
        t2.start();
    }

}

运行结果：
在这里插入图片描述
在这里插入图片描述

读锁和写锁之间互斥测试：

public class ReadWriteLockTest2 {
    public static void main(String[] args) {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

        Thread t1 = new Thread(()->{
            readLock.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("读加锁");
            }
            readLock.unlock();
        });

        Thread t2 = new Thread(()->{
            writeLock.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("写加锁");
            }
            writeLock.unlock();
        });

        t1.start();
        t2.start();
    }

}

前面全是读加锁：
在这里插入图片描述
后面全是写加锁：
在这里插入图片描述

写锁和写锁之间互斥测试：

public class ReadWriteLockTest3 {
    public static void main(String[] args) {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock writeLock1 = rwLock.writeLock();
        ReentrantReadWriteLock.WriteLock writeLock2 = rwLock.writeLock();

        Thread t1 = new Thread(()->{
            writeLock1.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("读加锁 1");
            }
            writeLock2.unlock();
        });

        Thread t2 = new Thread(()->{
            writeLock2.lock();
            for (int i = 0; i < 100; i++) {
                System.out.println("写加锁 2");
            }
            writeLock2.unlock();
        });

        t1.start();
        t2.start();
    }
}

前面全是写加锁1:
在这里插入图片描述
后面全是写加锁2:
在这里插入图片描述

1.5公平锁和非公平锁

公平锁
线程A和B竞争一把锁，线程A抢到了锁，线程B等待。
线程A还没释放锁，此时又多了一个线程C和线程B竞争。
等线程A释放锁后，按照先来后到原则，这把锁🔒给线程B。
这就是公平锁。

非公平锁
线程A和B竞争一把锁，线程A抢到了锁，线程B等待。
线程A还没释放锁，此时又多了一个线程C和线程B竞争。
等线程A释放锁后，这把锁🔒随机分配给线程B或者线程C。
这就是非公平锁。

1.6可重入锁和非可重入锁

且看下面这段代码：

public class ReeantrantAndUnReeantrant {
    public static Object locker = new Object();
    public static void main(String[] args) {
        synchronized (locker) {
            synchronized (locker) {
                System.out.println("ABC");
            }
        }
    }
}

会不会打印ABC?

执行结果：
在这里插入图片描述
结果打印了ABC，为什么呢？😕

在java中synchronized是可重入锁。那到底什么是可重入锁？

可重入锁

可重入锁是当一个线程获取一个锁多次，这个线程仍然可以拿到这个锁。
在这里插入图片描述
在这里插入图片描述

不可重入锁
不可重入锁跟可重入锁相反，一个线程拿到一个锁后，后面再尝试拿锁是拿不了的。
在这里插入图片描述

在这里插入图片描述

2.CAS

2.1什么是CAS

CAS全称是Compare And Swap，中文译过来就是比较并交换。
CAS操作通常涉及到两个寄存器和内存中的一个变量。

寄存器A里的值和变量V里的值进行比较，
如果相等，把寄存器B里的值给V。
如果不等，则操作失败。

如下图：

🚩比较
在这里插入图片描述
🚩交换
在这里插入图片描述

伪代码：

boolean CAS(address, expectValue, swapValue) {
 if (&address == expectedValue) {
   &address = swapValue;
        return true;
   }
    return false;
}

这里的伪代码只是为了更好地理解CAS，真正的CAS操作是靠一个原子的硬件指令完成的。

2.2CAS的应用

1.原子类
java.util.concurrent.atomic包下，都是基于CAS实现的。
比如:AtomicInteger类，提供了getAndIncrement()和incrementAndGet()对象方法。
getAndIncrement()相当于i++
incrementAndGet()相当于++i
不过这两个操作都是原子的。

案例：

public class AtomicTest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger();

        //创建线程t1，并执行incrementAndGet()方法10000次
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 10000; i++) {
                int val = atomicInteger.incrementAndGet();
                System.out.println(val);
            }
        });

        //创建线程t2，并执行incrementAndGet()方法10000次
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 10000; i++) {
                int val = atomicInteger.incrementAndGet();
                System.out.println(val);
            }
        });

        t1.start();
        t2.start();
    }
}

实现原子类的伪代码：

class AtomicInteger {
    private int value;
    public int getAndIncrement() {
        int oldValue = value;
        while ( CAS(value, oldValue, oldValue+1) != true) {
            oldValue = value;
       }
        return oldValue;
   }
}

2.实现自旋锁
伪代码：

public class SpinLock {
    private Thread owner = null;
    public void lock(){
        // 通过 CAS 看当前锁是否被某个线程持有. 
        // 如果这个锁已经被别的线程持有, 那么就自旋等待. 
        // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程. 
        while(!CAS(this.owner, null, Thread.currentThread())){
       }
   }
    public void unlock (){
        this.owner = null;
   }
}

3.ABA问题

现有线程A，线程A想把变量val的值改为3，需要做的操作如下：

  • 先读取 val 的值, 记录到 oldVal 变量中.
  • 使用 CAS 判定当前 val 的值是否为 oldVal, 如果为oldVal, 就把val改为3。

伪代码如下：

oldVal = val;
while (CAS(val, oldVal, 3) != true) {
	oldVal = val;
}

假设线程A中的val本来为7，此时oldVal=7，期望是把val改为3。
但是线程A在执行CAS操作之前
线程B，有可能把val改为5。
线程C，有可能把val再改为7。
这时候到底要不要把val改为3呢？

这就是ABA问题：
虽然这是小概率事件，但是有可能发生，这种情况下不能修改val的值，因为现实世界种有一些特殊情况，如果改了会出问题。

解决方案：

1.设置一个版本号
2.读取旧值的时候，也要读取版本号

  • 如果版本号相同，就修改数据，并且把版本号+1
  • 如果版本号不相同，就操作失败。

3.synchronized优化

3.1锁升级

jvm会根据线程之间竞争锁的激烈程度，对锁进行升级，如下图：
在这里插入图片描述
偏向锁
偏向锁不是锁，只是一个标志，标志着这个锁属于哪个线程。
如果后面没有锁竞争，就不进行其他同步操作了。
如果后面有其他线程来竞争这个锁，那么就将变成轻量级锁(自旋锁实现)。

轻量级锁
这里的轻量级锁基于自旋锁实现，即线程一直判断锁是否被释放，尝试获取这把锁。

重量级锁
随着锁的竞争愈发激烈，轻量级锁变成了重量级锁。没抢到锁的线程被操作系统内核等待挂起，直到下次唤醒，继续竞争锁。

3.2锁消除

jvm+编译器会判断锁是否可以消除，如果可以就消除。
就比如下面这段代码：

public class LockEliminate {
    public static Object lock = new Object();
    public static void main(String[] args) {
        int count = 0;
        synchronized (lock) {
            for (int i = 0; i < 100000; i++) {
                count++;
            }
        }
        System.out.println(count);
    }
}

只有主线程一个线程，但是却加了锁，这个锁完全没有必要存在，这时候就可以把锁消除掉。

3.3锁粗化

锁的粒度
锁的粒度是指被锁住代码的多少。
比如下面这段代码：

synchronized (this) {
	System.out.println("Hello, World");
}

因为被锁住的代码很少，锁的粒度很细。
如果被锁住的代码很多，锁的粒度就很粗。

看下面这段代码：

public class LockLightAndStrong {
    public static Object o = new Object();
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            synchronized (o) {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
            
            synchronized (o) {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
        });
        
    }
}

在线程t中，完全没有必要加两次锁，解两次锁。
但是如果没有其他线程来竞争这个锁，编译器和JVM就会进行锁的粗化。
从而更好地节省资源，避免频繁地加锁解锁。

西伯利亚小土豆
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVAEE 常见性能问题解决手册
02-28
【JAVAEE Web开发常见性能问题】在开发和部署企业级JAVA应用程序时，性能优化是一个至关重要的环节。本文基于Steven Haines的《PRO JAVA EE 5 Performance Management and Optimization》一书，探讨了Java EE环境中...
JavaEE期末复习模拟题
05-23
JavaEE是Java企业版（Java Enterprise Edition）的简称，它是一个用于开发企业级应用程序的Java平台。这个平台包含了多个服务、APIs和协议，旨在帮助开发者构建可扩展、高性能、安全且可管理的网络应用程序。JavaEE...
常见的锁策略,synchronized优化过程和cas过程
ling_zu_qi的博客
04-14 1859
常见锁策略,锁优化,CAS
【JavaEE初阶】多线程进阶（五）常见锁策略 CAS synchronized优化原理
xxxflower的博客
05-07 674
CAS: 全称Compare and swap，字面意思:”比较并交换“，一个 CAS 涉及到以下操作：我们假设内存中的原数据V，旧的预期值A，需要修改的新值B。比较 A 与 V 是否相等。（比较）如果比较相等，将 B 写入 V。（交换）返回操作是否成功。此处最特别的地方，上述这个CAS的过程，并非是通过一段代码实现的。而是通过一条CPU指令完成的。也就是说**CAS操作是原子的。**原子的也就可以在一定程度上回避线程安全问题。
JavaEE之锁策略,cas 和 synchronized 优化过程深入浅出
weixin_67836079的博客
04-15 928
锁策略,锁升级,锁优化
JavaEE--锁策略+synchronized优化+CAS
Lotus_zyz的博客
04-23 732
CAS，全称为compare and swap，意为比较和交换，在进行比较后将内存地址和寄存器中的值进行交换，这个操作过程在整体上是一条cpu指令，CAS的流程可以想象成一个方法boolean cas(address,reg1,reg2){//address内存地址，reg1,reg2寄存器//交换address内存地址中的值和reg2寄存器中的值//一般更关心交换交换后内存地址中的值，所以可以大致认为是把reg2寄存器中的值赋给内存地址。
【JavaEE】锁策略和CAS
2302_79806056的博客
08-18 840
在深入学习基本锁策略和CAS（Compare-and-Swap）操作的过程中，我对并发编程有了更深刻的理解。这些知识点不仅增强了我的编程技能，还帮助我更好地应对多线程环境下的挑战。以下是我在学习过程中的总结与反思。基本锁策略基本锁策略包括悲观锁、乐观锁、自旋锁、挂起等待锁、可重入锁、不可重入锁、公平锁、非公平锁、轻量级锁和重量级锁等。每种锁策略都有其独特的应用场景和优缺点。悲观锁与乐观锁悲观锁假设数据很可能被并发修改，因此在读取或写入数据之前会锁定数据，确保数据的一致性。
总结锁策略, cas 和 synchronized 优化过程
m0_70343551的博客
03-03 525
乐观锁在加锁之前,预估当前出现锁冲突的概率不大,因此在进行加锁的时候就不会做太多工作加锁过程做的事情比较少,加锁的速度可能就更快,但是也更容易引入一些其他问题悲观锁在家所之前,预估当前锁冲突出现的概率比较大,加锁的时候,会做很多工作做的事情多,加锁的速度可能更慢,整个过程不容易出现其它问题加锁之前对未发生的事进行预估。
【javaEE】多线程进阶（Part1 锁策略、CAS、synchronized ）
Xian meng在努力呐-的博客
11-07 796
1. 描述一下线程池的执行流程和拒绝策略有哪些？【面试题！】 2. 常见锁策略 + 面试题 3. CAS + CAS的ABA问题 + 面试题 4. synchronized原理（特点+加锁过程+优化手段）+面试题！ 5. 面试题超级重要！！！
JavaEE初阶----总结锁策略,CAS 和 synchronized 优化过程
m0_56642224的博客
04-11 348
⭐️常见锁策略 这个部分主要是一些面试常考的八股文，主要是为了应付面试。不必太纠结其细节。 🔴注意： 锁策略和普通的程序猿基本没啥关系和”实现锁“的人才有关系。 这里所提到的“锁策略”，和 Java 本身没有关系，适用于所有和“锁”相关的情况。 💥1.悲观锁VS乐观锁 🔴悲观锁： 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这 样别人想拿这个数据就会阻塞直到它拿到锁。
【JavaEE初阶】常见的锁策略及synchronized实现原理
2301_81510374的博客
08-08 1019
接下来讲解的锁策略不仅仅是局限于 Java . 任何和 “锁” 相关的话题, 都可能会涉及到以下内容. 这些特性主要是给锁的实现者来参考的.普通的程序猿也需要了解一些, 对于合理的使用锁也是有很大帮助的所说的策略，是这把锁，在加锁/解锁/遇到锁冲突的时候，都会怎么做，"策略"可以理解为"做法"。
javaEE-嵌套For循环性能优化案例借鉴.pdf
12-25
在JavaEE开发中，性能优化是一个至关重要的环节，特别是在处理大量数据或复杂计算时。嵌套for循环作为常见的编程结构，其效率直接影响到程序的运行速度。本文通过一个具体的案例，探讨了如何对嵌套for循环进行性能...
JavaEE应用开发环境介绍及搭建过程简易教程
04-10
JavaEE应用开发环境的搭建是开发企业级Java应用程序的关键步骤，这个过程涉及到多个组件的选取和配置。首先，我们需要理解JavaEE（Java Platform, Enterprise Edition）的性质，它是一个用于开发分布式企业应用的...
基于JavaEE的淘宝天猫京东数据优化购物系统.zip
04-11
该系统是一个基于JavaEE平台开发的电子商务应用，旨在优化淘宝、天猫、京东等大型电商平台的数据处理和购物体验。以下是对该系统的关键知识点的详细说明： 1. **JavaEE技术栈**： JavaEE（Java Platform, ...
基于JavaEE的农产品销售管理系统设计与实现(源码+lw+部署文档+讲解等)
最新发布
qq_43701267的博客
08-20 514
💗博主介绍：✌闲鱼大玩家全栈领域优质创作者，博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java、小程序技术领域和毕业项目实战✌💗👇🏻 精彩专栏 推荐订阅👇🏻设计与实现(源码+lw+部署文档+讲解等)2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅微信小程序项目精品案例《100套》✅Java精品实战案例《500套》✅🌟文末获取源码+数据库🌟。
web后端（javaEE）开发——servlet
2301_78341216的博客
08-20 632
web后端，Servlet
【JavaEE】MyBatis 实战指南：从 JDBC 到高效数据库操作的进阶教程
Hsusan的博客
08-17 888
MyBatis 是⼀款优秀的持久层框架，⽤于简化JDBC的开发。而且本身和 Spring 没有任何关系。本质就是操作数据库的框架MyBatis 本是 Apache的⼀个开源项⽬iBatis，2010年这个项⽬由 apache 迁移到了 google code，并且改名为 MyBatis。2013年11⽉迁移到Github。官⽹：https://mybatis.org/mybatis-3/zh/index.html在上⾯我们提到⼀个词：持久层。
【JavaEE初阶】UDP客户端和服务器的搭建
2301_81510374的博客
08-17 1242
整体代码：注意：当程序启动之后，代码执行到receive的时候，如果没有客户端发送请求，服务器的代码就会在这里阻塞（跟锁关系不大，这里的阻塞都是系统内核控制的），直到说有客户端发来请求。运行程序： 通过jconsole查看：
JavaEE多线程进阶：乐观锁与悲观锁策略解析
本笔记深入探讨了JAVAEE中的多线程进阶知识，主要涉及常见的锁策略以及CAS（Compare and Swap）机制。首先，介绍了两种基本的锁概念：乐观锁与悲观锁。 乐观锁假设在大部分情况下数据不会发生并发冲突，只在更新时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值