锁的笔记整理
文章目录
管程
-
含义
管程,指的是管理共享变量以及对共享变量的操作过程-
如何解决互斥的问题
将共享变量及其对共享变量的操作统一封装起来,看下面那张图 -
如何解决线程同步问题
管程模型里,共享变量和对共享变量的操作是被封装起来的,图中最外层的框就代表封装的意思。框的上面只有一个入口,并且在入口旁边还有一个入口等待队列。当多个线程同时试图进入管程内部时,只允许一个线程进入,其他线程则在入口等待队列中等待,管程里还引入了条件变量的概念,而且 每个条件变量都对应有一个等待队列。通过条件变量和等待队列,解决同步问题,想想notify,wait的原理实现-
管程的组成
- 一个锁:控制管程代码的互斥访问
- 入口队列:每次只能有一个线程进入
- 0或多个条件变量:管理共享数据的并发访问,每个条件变量对应有一个等待队列
-
MESA 模型
MESA 管程里面,T2 通知完 T1 后,T2 还是会接着执行,T1 并不立即执行(即调用了notify后,wait并后后面的代码没有马上执行,只是进入了waitSet队列等待锁的抢夺,此时是阻塞状态,而是等待notify释放锁后,wait才开始竞争锁,夺锁成功后,继续执行后续代码),仅仅是从条件变量的等待队列进到入口等待队列里面。
这样做的好处是 notify() 不用放到代码的最后,T2 也没有多余的阻塞唤醒操作。但是也有 个副作用,就是当 T1 再次执行的时候,可能曾经满足的条件,现在已经不满足了,所以需要以循环方式检验条件变量
-
-
如何解决互斥的问题


synchronized wait notify notifyAll 注意点
- 从Object对象wait方法文档注释有这么一句话"This method should only be called by a thread that is the owner of this object’s monitor",看出wait方法使用,必须拥有当前对象的监视器的锁,即wait的使用要在synchronized方法块之内;
- synchronized方法块同步方式是在字节码层面加入了monitorenter和monitorexit指令;
synchronized方法级别同步方式则是由常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的,如果这个标志被设置,如果是实例方法,则获取对象的锁,如果是类方法,则获取类锁。 - notify 和notifyAll的选择时要思考下使用哪一个,因为notify是通知一个线程,那么在同一个锁下,多个线程获取了不同资源的情况,notify其中一个线程,可能不能满足循环条件的结束,这样真正需要唤醒的线程就醒不来啦,哈哈
-
nofity使用的情况:
- 所有等待线程拥有相同的等待条件,如果条件不同,则唤醒后依旧阻塞,就浪费了机会
- 所有等待线程被唤醒后,执行相同的操作
- 只需要唤醒一个线程
- 从管程角度看,synchronized 仅支持一个条件变量,调用wait方法的句柄就是条件变量
- 从下面的代码结果可知:notifyAll本身不会释放锁,需要离开synchronized 区域才会释放锁;之前等待的线程被唤醒之后,会再次进行争夺互斥锁,获取锁后,状态则恢复到进入synchronized那时状态,继续执行wait后面的代码

public class TestMain {
private static List<String> list = new ArrayList<>(2);
public static void main(String[] args) throws InterruptedException {
TestMain testMain = new TestMain();
list.add("1");
Thread thread2 = new Thread(() -> testMain.apply("1","2"));
Thread thread3 = new Thread(() -> testMain.apply("1","2"));
Thread thread4 = new Thread(() -> testMain.free("1","2"));
thread2.start();
thread3.start();
TimeUnit.SECONDS.sleep(1);
System.out.println("开始执行通知代码块");
thread4.start();
}
public synchronized void apply(String one, String two) {
System.out.println("获取锁 进入 apply = " + Thread.currentThread().getName());
while (list.contains(one) || list.contains(two)) {
try {
System.out.println("开始等待,并且释放锁 = " + Thread.currentThread().getName());
wait();
System.out.println("拿到锁了,进入条件判断 = " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("离开 释放锁 = " + Thread.currentThread().getName());
}
public synchronized void free(String one ,String two) {
list.remove(one);
list.remove(two);
notifyAll();
System.out.println("通知完成 离开代码块 释放锁 = " + Thread.currentThread().getName());
}
}
-- 结果
获取锁 进入 apply = Thread-1
开始等待,并且释放锁 = Thread-1
获取锁 进入 apply = Thread-0
开始等待,并且释放锁 = Thread-0
开始执行通知代码块
通知完成 离开代码块 释放锁 = Thread-2
拿到锁了,进入条件判断 = Thread-0
离开 释放锁 = Thread-0
拿到锁了,进入条件判断 = Thread-1
离开 释放锁 = Thread-1
死锁
-
以下四点共同发生,就会产生死锁,所以破坏某一个条件,终止死锁
- 互斥,共享资源 X 和 Y 只能被一个线程占用,
资源具有互斥性 - 占有且等待,线程 T1 已经取得共享资源 X,在等待共享资源Y 的时候,不释放共享资源 X
破坏这种处境:一次性获取需要的所有资源,
- 不可抢占,其他线程不能强行抢占线程 T1 占有的资源
破坏处境:看lock实现,后续在补充 - 循环等待,A等B的条件,B等A的条件,相互等待
破坏处境:按照顺序申请资源,这样不会产生互相等待资源的局面,比如从按照id大小进行锁定对象
- 互斥,共享资源 X 和 Y 只能被一个线程占用,
synchronized实现原理以及锁的升级过程
-
源码实现
对象的内存布局,可分三个区域:header, Instance data,Padding, Hotspot采用instanceOopDesc和arrayOopDesc来描述对象头。
从底层源码oop.hpp可看出,实例对象中有一个成员变量markOop类型的_mark, 从 markOop.hpp文件看出,里面包含了锁标识位,标识了无锁,偏向锁,轻量级锁,重量级锁的状态值,还有分代年龄,GC标志等信息,所以sychronized(lock)中的lock可以用Java中任何一个对象来表示, 而锁标识的存储实际上就是在lock这个对象中的对象头内。
首先,Java中的每个对象都派生自Object类,而每个Java Object在JVM内部都有一个native的C++对象 oop/oopDesc 进行对应。
其次,线程在获取锁的时候,实际上就是获得一个监视器对象(monitor) ,monitor可以认为是一个同步对象,所有的Java对象是天生携带monitor, 同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识,表示该锁被这个线程占用。 - 偏向锁
- 根据锁对象的对象头,判断mark是否是偏向锁状态,不是则创建一个markword,进行首次的CAS操作,设置偏向锁状态
如果对象头已经包含了偏向锁状态标识,检测Mark Word里是否存储着指向当前线程的偏向锁如果存在,
则返回,否则 说明存在锁竞争,需要进行偏向锁的释放 -
偏向锁的释放,需要等待全局安全点(在这个时间点上没有正在执行的字节码),首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否还活着,
如果线程不处于活动状态,则将对象头设置成无锁状态。
如果线程仍然活着,则会升级为轻量级锁,偏向锁撤销以后对象会可能会处于两种状态:
- 一种是不可偏向的无锁状态,简单来说就是已经获得偏向锁的线程已经退出了同步代码块,那么这个时候会撤销偏向锁, 并升级为轻量级锁
- 一种是不可偏向的已锁状态,简单来说就是已经获得偏向锁的线程正在执行同步代码块,那么这个时候会升级到轻量级锁并且被原持有锁的线程获得锁

-
轻量锁的获取
JVM会先在当前线程的栈帧中创建用于存储锁记录的空间(LockRecord),将对象头中的Mark Word复制到锁记录中,称为Displaced Mark Word.拷贝成功后,虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针,并将Lock Record里的owner指针指向对象的Mark Word。
如果轻量级锁的更新操作失败了,虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧,如果是就说明当前线程已经拥有了这个对象的锁,那就可以直接进入同步块继续执行,否则说明多个线程竞争锁。
若当前只有一个等待线程,则该线程通过自旋进行等待。但是当自旋超过一定的次数,或者一个线程在持有锁,一个在自旋,又有第三个来访时,轻量级锁升级为重量级锁。 -
轻量锁的释放
将当前线程栈帧中锁记录空间中的Mark Word替换到锁对象的对象头中,如果成功表示锁释放成功。否则,锁膨胀成重量级锁,实现重量级锁的释放锁逻辑

-
为什么重量级锁的开销比较大呢?
原因是当系统检查到是重量级锁之后,会把等待想要获取锁的线程阻塞,被阻塞的线程不会消耗CPU,但是阻塞或者唤醒一个线程,都需要通过操作系统来实现,也就是相当于从用户态转化到内核态,而转化状态是需要消耗时间的
-
重量级锁获取
通过CAS将monitor的 _owner字段设置为当前线程,如果设置成功,则直接返回
如果之前的 _owner指向的是当前的线程,说明是重入,执行 _recursions++增加重入次数
如果获取锁失败,则需要通过自旋的方式等待锁释放
如果在指定的阈值范围内没有获得锁,则通过park将当前线程挂起,等待被唤醒

-
总结
偏向锁通过对比Mark Word解决加锁问题,避免执行CAS操作。
而轻量级锁是通过用CAS操作和自旋来解决加锁问题,避免线程阻塞和唤醒而影响性能。
重量级锁是将除了拥有锁的线程以外的线程都阻塞
以上内容来自以下资料的汇总整理:
极客时间java并发专栏
不可不说的Java“锁”事
synchronized的源码分析
Synchronized原理分析
深入分析synchronized的实现原理
synchronized 的锁膨胀过程

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论