无锁 ——> 偏向锁 ——> 轻量级锁 ——> 重量级锁

image.png
synchronized锁：由对象头中的 Mark Word 根据锁标志位的不同而被复用及锁升级策略。
image.png

偏向锁-单个线程多次访问

image.png
当一段同步代码一直被同一个线程多次访问，由于只有一个线程那么该线程在后续访问时便会自动获得锁(偏向锁)。

偏向锁的理论：

  1. 在实际应用运行过程中发现,“锁总是同一个线程持有， 很少发生竞争”,也就是说锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。
  2. 那么只需要在锁第一次被拥有的时候，记录下偏向线程ID。这样偏向线程就一直持有着锁(后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁。而是直接比较对象头里面是否存储了指向当前线程的偏向锁)。
  3. 如果相等表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了，直到竞争发生才释放锁。以后每次同步，检查锁的偏向线程ID与当前线程ID是否一致，如果一致直接进入同步。无需每次加锁解锁都去CAS更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。
  4. 假如不一致意味着发生了竞争，锁已经不是总是偏向于同一个线程了，这时候可能需要升级变为轻量级锁，才能保证线程间公平竞争锁。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

image.png
image.png

偏向锁的撤销

image.png

轻量级锁-多个线程竞争

主要作用(本质就是自旋锁)：
有线程来参与锁的竞争，但是获取锁的冲突时间极短。

理论落地：

  1. 轻量级锁是为了在线程近乎交替执行同步块时提高性能
  2. 主要目的: 在没有多线程竞争的前提下,通过CAS减少重量级锁使用操作系统互斥量产生的性能消耗,说白了先自旋再阻塞
  3. 升级时机:当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级锁
  4. 假如线程A已经拿到锁,这时线程B又来抢该对象的锁,由于该对象的锁已经被线程A拿到,当前该锁已是偏向锁了。

而线程B在争抢时发现对象头Mark Word中的线程ID不是线程B自己的线程ID(而是线程A),那线程B就会进行CAS操作希望能获得锁。
此时线程B操作中有两种情况
如果锁获取成功,直接替换Mark Word中的线程ID为B自己的ID(A → B),重新偏向于其他线程(即将偏向锁交给其他线程,相当于当前线程”被”释放了锁),该锁会保持偏向锁状态,A线程Over,B线程上位


Java6之后:自适应(自适应意味着自旋的次数不是固定不变的),而是根据:同一个锁上一次自旋的时间和拥有锁线程的状态来决定。

轻量锁与偏向锁的区别和不同

  1. 争夺轻量级锁失败时，自旋尝试抢占锁。
  2. 轻量级锁每次退出同步块都需要释放锁，而偏向锁是在竞争发生时才释放锁。

锁的优缺点

image.png

锁消除

锁消除：从JIT角度看相当于无视它，synchronized(o)不存在了，这个锁对象并没有被共用扩散到其它线程使用，极端的说就是根本没有加这个锁对象的底层机器码，消除了锁的使用。

  1. **
  2.  * 锁消除
  3.  * 从JIT角度看相当于无视它,synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用,
  4.  * 极端的说就是根本没有加这个锁对象的底层机器码,消除了锁的使用
  5.  */
  6. public class LockClearUPDemo{
  7.     static Object objectLock = new Object();//正常的
  9.     public void m1(){
  10.         //锁消除,JIT会无视它,synchronized(对象锁)不存在了。不正常的
  11.         Object o = new Object();
  13.         synchronized (o){
  14.             System.out.println("-----hello LockClearUPDemo"+"\t"+o.hashCode()+"\t"+objectLock.hashCode());
  15.         }
  16.     }
  18.     public static void main(String[] args){
  19.         LockClearUPDemo demo = new LockClearUPDemo();
  21.         for (int i = 1; i <=10; i++) {
  22.             new Thread(() -> {
  23.                 demo.m1();
  24.             },String.valueOf(i)).start();
  25.         }
  26.     }
  27. }

锁粗化

锁粗化：假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁,提升了性能。

  1. /**
  2.  * 锁粗化
  3.  * 假如方法中首尾相接,前后相邻的都是同一个锁对象,那JIT编译器就会把这几个synchronized块合并成一个大块,
  4.  * 加粗加大范围,一次申请锁使用即可,避免次次的申请和释放锁,提升了性能
  5.  */
  6. public class LockBigDemo
  7. {
  8.     static Object objectLock = new Object();
  11.     public static void main(String[] args)
  12.     {
  13.         new Thread(() -> {
  14.             synchronized (objectLock) {
  15.                 System.out.println("11111");
  16.             }
  17.             synchronized (objectLock) {
  18.                 System.out.println("22222");
  19.             }
  20.             synchronized (objectLock) {
  21.                 System.out.println("33333");
  22.             }
  23.         },"a").start();
  25.         new Thread(() -> {
  26.             synchronized (objectLock) {
  27.                 System.out.println("44444");
  28.             }
  29.             synchronized (objectLock) {
  30.                 System.out.println("55555");
  31.             }
  32.             synchronized (objectLock) {
  33.                 System.out.println("66666");
  34.             }
  35.         },"b").start();
  37.     }
  38. }