前言
🌟🌟本期讲解关于锁的相关知识了解，这里涉及到高频面试题哦~~~
🌈上期博客在这里：【JavaEE初阶】深入理解线程池的概念以及Java标准库提供的方法参数分析-CSDN博客
🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客
目录
📚️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的指令
其内部伪代码：
boolean CAS(address,expectValue,swapValue){
if(&address==expectValue){
&address=swapValue;
return true;
}
return false
}注意：这里是一段伪代码，不能进行运行，只是描述逻辑的，即先进行判断寄存器的值和地址值是否相等，相等就将另一个swap寄存器的值给地址值（内存地址值）
4.2CAS实现线程安全
CAS是CPU的一种指令，操作系统又对这个指令进行了封装，我们的Java又对操作系统的API进行了封装，那么我们就可以进行使用啦；
在之前我们在实现两个线程对count实现加法操作，需要进行加锁，但是有了CAS就可以不用进行加锁了；
代码如下：
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的实现和我们之前线程安全的代码的举例，本篇主要是涉及到（关于锁面试题）~~~
🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！
💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。
😊😊 期待你的关注~~~
扫一扫
908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
