【JavaEE初阶】深入理解不同锁的意义,synchronized的加锁过程理解以及CAS的原子性实现(面试经典题);

前言

🌟🌟本期讲解关于锁的相关知识了解,这里涉及到高频面试题哦~~~

🌈上期博客在这里: 【JavaEE初阶】深入理解线程池的概念以及Java标准库提供的方法参数分析-CSDN博客

🌈感兴趣的小伙伴看一看小编主页:GGBondlctrl-CSDN博客

目录

📚️1.引言

📚️2.锁的策略

2.1乐观锁与悲观锁

2.2轻量级锁和重量级锁

2.3自旋锁和挂起等待锁

2.4普通互斥锁和读写锁

2.5公平锁和非公平锁

2.6可重入锁和不可重入锁

📚️3.synchronized的加锁过程

3.1锁升级

1.偏向锁阶段

2.轻量级锁

3.重量级锁

3.2锁消除

3.3锁粗化

📚️4.CAS的实现原理

4.1CAS的内部逻辑

4.2CAS实现线程安全

4.3CAS的原子性

📚️5.总结

📚️1.引言

Hello!uu们小编又来啦,上期在介绍过线程池的理解后,相信大家已经对其有了更深的了解,致此多线程初阶已经完结,前面的博客也可以供大家学习,复习哟~~~

本期只要是讲解关于不同锁的不同的意义理解,例如:乐观锁和悲观锁,以及synchronized的加锁之前的操作.......那就直接开始吧!!!

📚️2.锁的策略

2.1乐观锁与悲观锁

这是锁的两种不同实现方式;

乐观锁:即加锁之前,预估在程序中的锁的冲突不大,因此在加锁的时候就不会进行太多的操作;

悲观锁: 即加锁之前,预估在程序中的锁的冲突很大,因此在加锁的时候就不会进行比较多的操作;

乐观锁的影响: 由于加锁的工作很少,所以加锁的时候就很快,但是缺点就是会造成更多的CPU资源的消耗(引入一些其他问题)

**悲观锁的影响:**由于加锁的时候工作比较多,所以在加锁的时候就比较满,所以此时造成的问题就很少;

2.2轻量级锁和重量级锁

轻量级锁:消耗的CPU资源多,加锁比较快=>这里理解为乐观锁;

重量级锁:消耗的CPU资源少,加锁比较慢=>这里理解为悲观锁;

这里的轻量级锁和重量级锁是加锁后对锁的一种评价,而乐观锁和悲观锁是加锁前的一种预估,这里是从两种不同的角度来描述一件事情;

2.3自旋锁和挂起等待锁

自旋锁:是轻量级锁的一种典型实现,一般搭配while循环,在加锁成功后退出循环,但是加锁不成功后,会进入循环再次尝试加锁;

挂起等待锁:是重量级锁的一种典型实现,在加锁失败后,会进入阻塞状态,直到获取到锁

自旋锁的使用:一般用于锁冲突比较小的情况,由于高速反复的尝试加锁,导致CPU的资源消耗上升,取而代之的是加锁的速度快,但是在线程多的情况下会发生"线程饿死"的问题

挂起等待锁的使用:一般用于所冲突比较大的情况,由于进入阻塞后,就是内核随机调度来进行执行,要进行的操作增加,导致加锁更慢了

synchronized锁 :这里的synchronized锁具有自适应的能力的,例如在锁冲突情况比较严重的时候,这里的synchronized就是悲观锁、重量级锁、挂起等待锁.....所以这里的synchronized是根据当时的锁的冲突情况来进行自适应的~~~

2.4普通互斥锁和读写锁

普通互斥锁:即synchronized类似,只有加锁和解锁

读写锁:这里的解锁是一样的,但是在加锁的时候分为两种即"加读锁"与"加写锁"

这里的情况就是:

读锁和读锁这之间,不会出现锁的冲突

读锁和写锁这之间,会出现锁的冲突

写锁和写锁这之间,会出现锁的冲突

即一个线程加读锁的时候,另一个线程是可以"读"的,但是是不可以"写"的;

即一个现场加写锁的时候,另一个线程是不可以进行"读"和"写"的

为什么要引入读写锁:

在线程的读的操作中,读这个操作本来就是线程安全的,但是使用synchronized任然要给这一部分要加锁,由于加锁这个操作本来就是一个低效率的操作;在读的过程中不加锁可以打打提升效率;

但是读的时候完全不加锁,可能会在读的时候进行写操作,所以这里又要加"读锁";

2.5公平锁和非公平锁

公平锁:即等待加锁的时间越久,就应该在锁释放的时候,先加上锁(先来先到原则)

非公平死锁:即在锁释放后,获取锁的概率是一样的,存在竞争;

如下图所示:

2.6可重入锁和不可重入锁

可重入锁:即在加锁过后任然在这个线程继续进行加锁;

不可重入锁:即在加锁过后,这个线程就不能进行加锁了;

例如synchronized是一个可重入锁,但是在系统中的锁是一个不可重入锁;

可重入锁需要记录加锁的对象,以及加锁的次数;

📚️3.synchronized的加锁过程

在synchronized加锁之前会经历一下升级过程

3.1锁升级

1.偏向锁阶段

这里的偏向锁阶段的实现和之前讲解的"懒汉模式"是有一定的联系的,即非必要不加锁,但是这里的偏向锁,并不是真正意义上的加锁;

偏向锁:即一种非必要不加锁的模式,真正意义上是不加锁的,而是进行一次轻量级的标记

这里就是当没有锁进行竞争的话就会不加锁,只是轻量化标记一下,当有锁的竞争,那么这个标记的就会很快拿到锁;

偏向锁的作用: 存在锁冲突的情况下,这中锁没有提高效率,但是当没有锁的竞争后,因为只是轻量化标记,而不加锁,那么这里的效率就会得到很大的提升;

2.轻量级锁

轻量级锁:即通过自旋的方式进行实现,反复快速的进行加锁的操作

优点:在锁的释放后,能够快速的拿到并加上锁;

缺点:非常消耗CPU的资源;

这里synchronized会根据有多少个线程在参与竞争,如果比较多,那么就会升级成重量级锁;

3.重量级锁

重量级锁:即拿不到锁的线程不会进入自旋状态,而是进入阻塞状态,释放CPU资源;

最后由内核进行随机调度,从而加上锁;

3.2锁消除

锁消除:即synchronized的一种优化策略,但是比较保守;

即编译器在编译的时候优化一下两种情况:

1.不存在锁竞争,只有一个线程,那么此时就会进行锁消除

2.加锁的代码中没有涉及到成员变量的改动,只有局部变量的改动,就不需要进行加锁

3.3锁粗化

锁粗化:即讲一个细粒度的锁,转化为一个粗粒度的锁;

粒度:即在synchronized{ },这个括号里的代码越少,即粒度越细;代码越多,即粒度越粗

所谓的粒度粗化,如下图所示:

可以发现,这里频繁的加锁解锁会造成额外的时间开销,而直接一步到位可以剩下这部分的时间开销;

📚️4.CAS的实现原理

4.1CAS的内部逻辑

所谓的CAS即compare and swap,即一种比较和交换,这是一个特殊的CPU的指令

其内部伪代码:

java 复制代码
boolean CAS(address,expectValue,swapValue){
      if(&address==expectValue){
          &address=swapValue;
          return true;
      }
      return false
}

**注意:**这里是一段伪代码,不能进行运行,只是描述逻辑的,即先进行判断寄存器的值和地址值是否相等,相等就将另一个swap寄存器的值给地址值(内存地址值)

4.2CAS实现线程安全

CAS是CPU的一种指令,操作系统又对这个指令进行了封装,我们的Java又对操作系统的API进行了封装,那么我们就可以进行使用啦;

在之前我们在实现两个线程对count实现加法操作,需要进行加锁,但是有了CAS就可以不用进行加锁了;

代码如下:

java 复制代码
public static AtomicInteger count=new AtomicInteger();
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                count.getAndIncrement();
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                count.getAndIncrement();
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终count的值为:"+count.get());
    }

这里就是通过使用原子类工具,实现了没有加锁的仍然线程安全的代码;

注意:之前的count++是三个指令,在线程的随机调度中存在不同指令的穿插的情况,导致线程安全问题,但是getandincrement本来就是一个线程安全的指令(就是一个指令),天然就具有原子性;

4.3CAS的原子性

在实现原子类的伪代码如下图所示

即起初内存中的值为value,oldvalue是寄存器中的值,进入循环,当比较成功,那么就value的值就为value+1了;

当存在随机调度的时候:

那么此时就会有以下操作:

第一步:执行右边线程的操作

第二步:进行随机调度走的代码

注意:在次比较发现内存和寄存器的值是不一样的了,此时就会进行再次读取内存,在次进行循环比较,发现一样了,就会加1跳出循环

代价:这里的代价,就是while循环造成的自旋,CPU的消耗;

📚️5.总结

💬💬本期小编讲解了关于不同锁的基本概念,包括我们经常使用synchronized的加锁过程包含的"锁升级,锁消除,锁粗化"的一系列的操作,以及CAS的实现和我们之前线程安全的代码的举例,本篇主要是涉及到(关于锁面试题)~~~

🌅🌅🌅~~~~最后希望与诸君共勉,共同进步!!!


💪💪💪以上就是本期内容了, 感兴趣的话,就关注小编吧。

😊😊 期待你的关注~~~

相关推荐
Dream_Snowar2 分钟前
速通Python 第三节
开发语言·python
黄油饼卷咖喱鸡就味增汤拌孜然羊肉炒饭17 分钟前
SpringBoot如何实现缓存预热?
java·spring boot·spring·缓存·程序员
暮湫33 分钟前
泛型(2)
java
超爱吃士力架38 分钟前
邀请逻辑
java·linux·后端
南宫生42 分钟前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
转码的小石1 小时前
12/21java基础
java
高山我梦口香糖1 小时前
[react]searchParams转普通对象
开发语言·前端·javascript
李小白661 小时前
Spring MVC(上)
java·spring·mvc
GoodStudyAndDayDayUp1 小时前
IDEA能够从mapper跳转到xml的插件
xml·java·intellij-idea
信号处理学渣1 小时前
matlab画图,选择性显示legend标签
开发语言·matlab