Java中的几种锁的实现原理及锁升级

Java6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁“。在Java 6以前，所有的锁都是”重量级“锁。所以在Java 6及其以后，一个对象其实有四种锁状态，它们级别由低到高依次是:

• 1.无锁状态
• 2.偏向锁状态
• 3.轻量级锁状态
• 4.重量级锁状态

无锁

无锁就是没有对资源进行锁定，任何线程都可以尝试去修改它，无锁在这里不再细讲。

几种锁会随着竞争情况逐渐升级，锁的升级很容易发生，但是锁降级发生的条件会比较苛刻，锁降级发生在Stop The World期间，当JVM进入安全点的时候，会检查是否有闲置的锁，然后进行降级。

Java中的对象头

对象组成分为3个区域：对象头、实例数据、对齐填充。
前面我们提到，Java的锁都是基于对象的。首先我们来看看1个对象的“锁”的信息是存放在什么地方的。

我们先看一下对象头
每个Java对象都有对象头。如果是非数组类型，则用2个字宽来存储对象头，如果是数组，则会用3个字宽来存储对象头。在32位处理器中，1个字宽是32位;在64位虚拟机中，1个字宽是64位。对象头的内容如下表:

长度	内容	说明
32/64bit	Mark Word	存储对象的hashcode的值
32/64bit	class指针	存储到对象类型的指针
32/64bit	数组长度	数组的长度 （如果是数组的话）

我们主要来看看Mark Word的格式；

锁状态	29bit/61bit	1bit是否是偏向锁	2bit锁标识位
无锁			01
偏向锁	线程ID	1	01
轻量级锁	指向栈中锁记录的指针	此时这里不用标识偏向锁	00
重量级锁	指向互斥量（重量级锁的指针）	👆	10
GC标识位		👆	11

可以看到，当对象状态为偏向锁时，Mark Word存储的是偏向的线程ID;当状态为轻量级锁时，Mark Word 存储的是指向线程栈中Lock Record 的指针;当状态为重量级锁时，Mark Word为指向堆中的monitor对象的指针。

偏向锁

自旋锁的目的是为了减少线程被挂起的几率，因为线程的挂起和唤醒也都是耗资源的操作。Hotspot的作者经过以往的研究发现大多数情况下锁不仅不存在多线程竞争，而且总是由同一线程多次获得，于是引入了偏向锁。 偏向锁会偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他的线程访问，则持有偏向锁的线程将永远不需要触发同步。也就是说，偏向锁在资源无竞争情况下消除了同步语句，连CAS操作都不做了，提高了程序的运行性能。

实现原理

1个线程在第一次进入同步块时，会在对象头和栈帧中的锁记录里存储锁的偏向的线程ID。当下次该线程进入这个同步块时，会去检查锁的Mark Word里面是不是放的自己的线程ID。如果是，表明该线程已经获得了锁，以后该线程在进入和退出同步块时不需要花费CAS操作来加锁和解锁;如果不是，就代表有另一个线程来竞争这个偏向锁。这个时候会尝试使用CAS来替换Mark Word里面的线程ID为新线程的ID,这个时候要
分两种情况:

• 成功，表示之前的线程不存在了，Mark Word里面的线程ID为新线程的ID，锁不会升级，仍然为偏向锁;
• 失败，表示之前的线程仍然存在，那么暂停之前的线程，设置偏向锁标识为0，并设置锁标志位为00，升级为轻量级锁，会按照轻量级锁的方式进行竞争锁。

撤销偏向锁

偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。

偏向锁升级成轻量级锁时，会暂停拥有偏向锁的线程，重置偏向锁标识，这个过程看起来容易，实则开销还是很大的，大概的过程如下:
1.在一个安全点(在这个时间点上没有字节码正在执行)停止拥有锁的线程。
2.遍历线程栈，如果存在锁记录的话，需要修复锁记录和Mark Word,使其变成无锁状态。
3.唤醒被停止的线程，将当前锁升级成轻量级锁。
示例图：

轻量级锁

多个线程在不同时段获取同-把锁，即不存在锁竞争的情况，也就没有线程阻塞。针对这种情况，JVM采用轻量级锁来避免线程的阻塞与唤醒。

加锁

线程尝试用CAS将锁的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示Mark Word已经被替换成了其他线程的锁记录，说明在与其它线程竞争锁，当前线程就尝试使用自旋来获取锁。

自旋是需要消耗CPU的，如果一直获取不到锁的话，那该线程就一直处在自旋状态，白白浪费CPU资源。解决这个问题最简单的办法就是指定自旋的次数，例如让其循环10次，如果还没获取到锁就进入阻塞状态。

但是JDK采用了更聪明的方式 — 适应性自旋，简单来说就是线程如果自旋成功了， 则下次自旋的次数会更多,如果自旋失败了，则自旋的次数就会减少。自旋也不是一直进行下去的，如果自旋到一-定程度(和JVM、 操作系统相关)，依然没有获取到锁，称为自旋失败，那么这个线程会阻塞。同时这个锁就会升级成重量级锁。

重量级锁

重量级锁依赖于操作系统的互斥量(mutex)实现的，而操作系统中线程间状态的转换需要相对比较长的时间，所以重量级锁效率很低，但被阻塞的线程不会消耗CPU。
前面说到，每一个对象都可以当做一个锁，当多个线程同时请求某个对象锁时，对象锁会设置几种状态用来区分请求的线程:

Contention List: 所有请求锁的线程将被首先放置到该竞争队列
Entry List: Contention List中那些有资格成为候选人的线程被移到Entry List
Wait Set: 那些调用wait方法被阻塞的线程被放置到Wait Set
OnDeck:任何时刻最多只能有一个线程正在竞争锁，该线程称为0nDeck
Owner:获得锁的线程称为Owner
!Owner:释放锁的线程

当一个线程尝试获得锁时，如果该锁已经被占用，则会将该线程封装成-个0bjectWaiter对象插入到Contention List的队列的队首，然后调用park 函数挂起当前线程。

当线程释放锁时，会从Contention List或EntryL ist中挑选一个线程唤醒，被选中的线程叫做Heir presumptive 即假定继承人，假定继承人被唤醒后会尝试获得锁,但synchronized是非公平的，所以假定继承人不一定能获得锁。这是因为对于重量级锁，线程先自旋尝试获得锁，这样做的目的是为了减少执行操作系统同步操作带来的开销。如果自旋不成功再进入等待队列。这对那些已经在等待队列中的线程来说，稍微显得不公平，还有一个不公平的地方是自旋线程可能会抢占了Ready线程的锁。
如果线程获得锁后调用object.wait 方法，则会将线程加入到WaitSet中，当被0bject.notify唤醒后，会将线程从WaitSet移动到Contention List或EntryList中去。需要注意的是，当调用一个锁对象的wait或notify方法时，如当前锁的状态是偏向锁或轻量级锁则会先膨胀成重量级锁。

总结锁升级的过程

每一个线程在准备获取共享资源时:
第一步，检查MarkWord里面是不是放的自己的Threadld，如果是，表示当前线程是处于“偏向锁”。

第二步，如果MarkWord不是自己的Threadld，锁升级，这时候，用CAS来执行切换，新的线程根据MarkWord里面现有的Threadld,通知之前线程暂停，之前线程将Markword的内容置为空。

第三步，两个线程都把锁对象的HashCode复制到自己新建的用于存储锁的记录空间，接着开始通过CAS操作，把锁对象的MarkWord的内容修改为自己新建的记录空间的地址的方式竞争MarkWord。

第四步，第三步中成功执行CAS的获得资源，失败的则进入自旋。

第五步，自旋的线程在自旋过程中，成功获得资源(即之前获的资源的线程执行完成并释放了共享资源)，则整个状态依然处于轻量级锁的状态，如果自旋失败。

第六步，进入重量级锁的状态，这个时候，自旋的线程进行阻塞，等待之前线程执行完成并唤醒自己。

各个线程的优缺点对比

锁	优点	缺点	适用场景
偏向锁	加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。	如果线程间存在锁竞争，会带来额外的锁撤销的消耗。	适用于只有个线程访问同步块场景。
轻量级锁	竞争的线程不会阻塞提高了程序的响应速度。	如果始终得不到锁，竞争的线程使用自旋会消耗CPU。	追求响应时间。同步块执行速度非常快。
重量级锁	线程竞争不使用自旋，不会消耗CPU。	线程阻塞，响应时间缓慢。	追求吞吐量。同步块执行速度较长。