锁的笔记整理

管程

  • 含义
    管程,指的是管理共享变量以及对共享变量的操作过程

    1. 如何解决互斥的问题
      将共享变量及其对共享变量的操作统一封装起来,看下面那张图
    2. 如何解决线程同步问题
      管程模型里,共享变量和对共享变量的操作是被封装起来的,图中最外层的框就代表封装的意思。框的上面只有一个入口,并且在入口旁边还有一个入口等待队列。当多个线程同时试图进入管程内部时,只允许一个线程进入,其他线程则在入口等待队列中等待,管程里还引入了条件变量的概念,而且 每个条件变量都对应有一个等待队列。通过条件变量和等待队列,解决同步问题,想想notify,wait的原理实现

      • 管程的组成

        • 一个锁:控制管程代码的互斥访问
        • 入口队列:每次只能有一个线程进入
        • 0或多个条件变量:管理共享数据的并发访问,每个条件变量对应有一个等待队列
      • MESA 模型

        MESA 管程里面,T2 通知完 T1 后,T2 还是会接着执行,T1 并不立即执行(即调用了notify后,wait并后后面的代码没有马上执行,只是进入了waitSet队列等待锁的抢夺,此时是阻塞状态,而是等待notify释放锁后,wait才开始竞争锁,夺锁成功后,继续执行后续代码),仅仅是从条件变量的等待队列进到入口等待队列里面。
            这样做的好处是 notify() 不用放到代码的最后,T2 也没有多余的阻塞唤醒操作。但是也有 个副作用,就是当 T1 再次执行的时候,可能曾经满足的条件,现在已经不满足了,所以需要以循环方式检验条件变量

clipboard.png

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后面的代码

clipboard.png

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![在这里插入图片描述](https://img-blog.csdnimg.cn/20190716202958253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pmYzA4MjY=,size_16,color_FFFFFF,t_70)
开始等待,并且释放锁 = Thread-1
获取锁 进入 apply = Thread-0
开始等待,并且释放锁 = Thread-0
开始执行通知代码块
通知完成 离开代码块 释放锁 = Thread-2
拿到锁了,进入条件判断 = Thread-0
离开 释放锁 = Thread-0
拿到锁了,进入条件判断 = Thread-1
离开 释放锁 = Thread-1

死锁

  • 以下四点共同发生,就会产生死锁,所以破坏某一个条件,终止死锁

    1. 互斥,共享资源 X 和 Y 只能被一个线程占用,资源具有互斥性
    2. 占有且等待,线程 T1 已经取得共享资源 X,在等待共享资源Y 的时候,不释放共享资源 X
      破坏这种处境:一次性获取需要的所有资源,
      图片来自极客时间课程
    3. 不可抢占,其他线程不能强行抢占线程 T1 占有的资源
      破坏处境:看lock实现,后续在补充
    4. 循环等待,A等B的条件,B等A的条件,相互等待
      破坏处境:按照顺序申请资源,这样不会产生互相等待资源的局面,比如从按照id大小进行锁定对象

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字段存放拥有该锁的线程的唯一标识,表示该锁被这个线程占用。
  • 偏向锁
  1. 根据锁对象的对象头,判断mark是否是偏向锁状态,不是则创建一个markword,进行首次的CAS操作,设置偏向锁状态

    如果对象头已经包含了偏向锁状态标识,检测Mark Word里是否存储着指向当前线程的偏向锁如果存在,
    则返回,否则 说明存在锁竞争,需要进行偏向锁的释放

  2. 偏向锁的释放,需要等待全局安全点(在这个时间点上没有正在执行的字节码),首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否还活着,
    如果线程不处于活动状态,则将对象头设置成无锁状态。
    如果线程仍然活着,则会升级为轻量级锁,

    偏向锁撤销以后对象会可能会处于两种状态:

    • 一种是不可偏向的无锁状态,简单来说就是已经获得偏向锁的线程已经退出了同步代码块,那么这个时候会撤销偏向锁, 并升级为轻量级锁
    • 一种是不可偏向的已锁状态,简单来说就是已经获得偏向锁的线程正在执行同步代码块,那么这个时候会升级到轻量级锁并且被原持有锁的线程获得锁

偏向锁的获取以及撤销

  • 轻量锁的获取
          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 的锁膨胀过程

评论

暂无评论