Java 多线程中的 volatile 关键字,synchronized 锁的实现原理以及优化后锁升级的过程

• Volatile

  • volatile只能保证可见性，有序性，不能保证原子性

• 一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

• 禁止进行指令重排序。

• 使用Volatile的场景：

• 对变量的写操作不依赖于当前值

• 该变量没有包含在具有其他变量的不变式中

• synchronized--重量级锁

  • 组成：我们都知道对象是放在堆内存中的，对象大致可以分为三个部分，分别是对象头，实例变量和填充字节

• synchronized能同时保证可见性，原子性，有序性

• 修饰普通方法

  • 锁住调普通方法的对象

  • 谁调用他，需要拿到锁

• static修饰的，锁住的是这个类所在的class

• 修饰一个代码块：小括号里面写啥就锁啥

• 锁升级（优化）锁升级的过程

  • 偏向锁-》轻量级锁-》重量级锁

    • 偏向锁升级原理：

      • 当线程1访问代码块并获取锁对象时，会在java对象头和栈帧中记录偏向的锁的threadID，因为偏向锁不会主动释放锁，因此以后线程1再次获取锁的时候，需要比较当前线程的threadID和Java对象头中的threadID是否一致，如果一致（还是线程1获取锁对象），则无需使用CAS来加锁、解锁；如果不一致（其他线程，如线程2要竞争锁对象，而偏向锁不会主动释放因此还是存储的线程1的threadID），那么需要查看Java对象头中记录的线程1是否存活，如果没有存活，那么锁对象被重置为无锁状态，其它线程（线程2）可以竞争将其设置为偏向锁；如果存活，那么立刻查找该线程（线程1）的栈帧信息，如果还是需要继续持有这个锁对象，那么暂停当前线程1，撤销偏向锁，升级为轻量级锁，如果线程1 不再使用该锁对象，那么将锁对象状态设为无锁状态，重新偏向新的线程。

    • 轻量级锁原理和升级过程

      • 线程1获取轻量级锁时会先把锁对象的对象头MarkWord复制一份到线程1的栈帧中创建的用于存储锁记录的空间（称为DisplacedMarkWord），然后使用CAS把对象头中的内容替换为线程1存储的锁记录（DisplacedMarkWord）的地址；

        如果在线程1复制对象头的同时（在线程1CAS之前），线程2也准备获取锁，复制了对象头到线程2的锁记录空间中，但是在线程2CAS的时候，发现线程1已经把对象头换了，线程2的CAS失败，那么线程2就尝试使用自旋锁来等待线程1释放锁。 自旋锁简单来说就是让线程2在循环中不断CAS

    • 重量级锁升级原理

      • 但是如果自旋的时间太长也不行，因为自旋是要消耗CPU的，因此自旋的次数是有限制的，比如10次或者100次，如果自旋次数到了线程1还没有释放锁，或者线程1还在执行，线程2还在自旋等待，这时又有一个线程3过来竞争这个锁对象，那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞，防止CPU空转。

锁升级：无锁->偏向锁-轻量级锁-重量级锁

• 锁升级的过程（1h29分）

• 无锁：首先是一个无锁的状态，代表着里面不涉及到锁，什么时候是无锁的状态呢 就是写了一个synchronized将一个对象锁住（写了一个对象），此时没有任何线程去访问这个对象，此时这个对象就是无锁状态，此时没有线程访问它

• 无锁-偏向锁：当第一个线程A访问到这个锁的同步代码块的时候，检查里面对象的状态，发现是无锁状态，然后就将它改成偏向锁状态并且将自己的线程id放进去，代表这个对象偏向我这个线程，然后这个线程就开始使用这个同步代码块包起来的程序了，开始执行，执行完毕，结束，锁不释放，等待这个线程下一次再一次执行这个同步代码块，检查id，发现是自己，于是该线程就又获得了这个锁，在这个条件下，比那些不加同步代码块的多一个对比的动作，即检查是不是自己的线程id，但是此时B线程也想访问这个同步代码块,B线程访问的时候发现这个代码块是偏向锁状态，检查id，发现不是自己的id，于是开始抢这个锁，到全局安全点的时候检查A线程是否存活：

  • 情况1：A线程已经死了，然后顺利的将同步代码块的id改成自己的id，自己拥有这个偏向锁

  • 偏向锁->轻量级锁；情况2：A线程还存活，让A线程先执行完他的程序，等A执行完毕，此时检查A线程是否存活

    • 如果此时A线程扔继续存活，那么未来可能还存在A继续使用的问题，此时将锁升级为轻量级锁，

    • 如果此时A线程已经死了，那么将同步代码块的id改为B线程的id，此时为B的偏向锁，过一段时间，C线程来使用同步代码块如果此时B线程已经死了，那么将锁改为C线程的id，即C的偏向锁，或者一段时间后A线程又存活，然后又使用该代码块，想改成自己的id，检查线程死没死的时候，使用GC机制，我们会记录线程的一个活了的偏向次数（改同步代码块的id为自己的id，将其改为自己的偏向锁），当偏向次数太多了，此时仍会修改锁为轻量级锁，此时该线程将对象的对象头MarkWord复制一份到他的栈帧中创建的用于存储锁记录的空间（称为DisplacedMarkWord），然后使用CAS把对象头中的内容替换为线程1存储的锁记录（DisplacedMarkWord）的地址，哪个线程没抢到锁，就循环抢，谁抢到了锁，就继续这个过程，此时循环访问同步代码块的线程循环问使用该锁的线程是否使用完毕，比如D线程一直询问C线程是否使用完毕这个锁，比如C线程使用完了，那么就交给了D线程使用，比如C线程一直使用不完，使用的时间很长，然后D线程就准备销毁死去，同时他将该对象头改为重量级锁的标记，改成重量级锁标记后，自己的线程因为没抢到锁，D线程改为阻塞，原来的C线程发现改为了重量级锁，于是cas失败（D线程将值改变了），此时哪个线程阻塞在这个锁这，那么就将这个阻塞的线程给唤醒（D线程），于是轻量级锁转变为重量级，C线程也结束了。

• 无锁：对象的hashCode、对象分代年龄、是否是偏向锁(0)

• 偏向锁： 偏向线程ID、偏向时间戳、对象分代年龄、是否是偏向锁(1)

  • 优点：加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级的差距

  • 缺点：如果线程间存在锁竞争，会带来额外的锁撤销的消耗

  • 适用于只有一个线程访问同步块场景

• 轻量级锁：指向栈中锁记录的指针

  • 优点：竞争的线程不会阻塞，提高了程序的响应速度

  • 缺点：如果始终得不到索竞争的线程，使用自旋会消耗CPU

  • 追求响应速度，同步块执行速度非常快

• 重量级锁：指向互斥量的指针

  • 优点：线程竞争不使用自旋，不会消耗CPU

  • 缺点：线程阻塞，响应时间缓慢

  • 追求吞吐量，同步块执行速度较慢

  • 

  

• 轻量级锁是指当锁是偏向锁的时候，却被另外的线程所访问，此时偏向锁就会升级为轻量级锁，其他线程会通过自旋（关于自旋的介绍见文末）的形式尝试获取锁，线程不会阻塞，从而提高性能。

• 无锁到（先到偏向锁）轻量级锁？

  • synchronized括起来

  • 一开始没有任何线程访问

  • A访问

  • A撤销

  • B访问 检查A是否活着

  • A撤销或者升级

• 偏向锁 -> 轻量级锁 -> 重量级锁