1、锁的分类
-
可重入锁、不可重入锁
-
重入：当前线程获得A锁，之后再次尝试获取A锁 是可以获取的
java中提供的synchronized、ReentrantLock、ReentrantReadWriterLock均是可重入锁
-
不可重入锁：当前线程获得A锁，之后再次尝试获取A锁，此时无法获得，需要等当前线程先释放A锁才能再获得A锁（容易造成死锁）
-
-
乐观锁、悲观锁
java中提供的synchronized、ReentrantLock、ReentrantReadWriterLock都是悲观锁
java中提供的CAS操作，是乐观锁
悲观锁：获取不到锁资源时，会将当前线程挂起（进入blocked、waiting），线程的挂起涉及到用户态和内核态的切换，这种切换时比较消耗资源的。
用户态：JVM可以自行执行的指令，不需要借助操作系统
内核态：JVM不可自行执行，需要操作系统才可以执行
乐观锁：获取不到锁资源，可以让CPU调度，重新尝试获取锁资源，Atomic原子类中就是基于CAS乐观锁实现的。
- 公平锁、非公平锁
非公平锁：线程A获得锁，线程B排队中，此时线程C来了，先去尝试竞争一波，拿到锁就插队成功，没拿到，则乖乖的在B后面排队。
synchronized、ReentrantLock、ReentrantReadWriterLock
公平锁：依次等待排队
ReentrantLock、ReentrantReadWriterLock
-
互斥锁、共享锁
互斥锁：同一时间只会有一个线程持有当前互斥锁
synchronized、ReentrantLock、ReentrantReadWriterLock
共享锁：同一时间当前共享锁可以被多个线程同时持有
ReentrantReadWriterLock
2、深入synchronized
2.1 类锁、对象锁
synchronized一般使用在同步方法或同步代码块中，它是基于对象实现的
同步方法：
static：此时使用的是当前类的class作为锁
非static：此时使用的是当前类的实例对象
2.2 synchronized的优化
锁消除：
在synchronized修饰的代码中，如果不存在操作临界资源的情况，会触发锁消除，即使写了synchronized，也不会触发
锁膨胀：
如果在一个循环中，频繁的获取和释放锁资源，这样带来的消耗很大，锁膨胀就是将锁的范围扩大，避免频繁的竞争和获取锁资源带来不必要的消耗。
for(int i =0;i<10000000;i++){
synchronized{}
}
// 此时上边的代码会触发锁膨胀，变为下方示例代码
synchronized{
for(int i =0;i<10000000;i++){}
}锁升级：ReentrantLock的实现，是基于乐观锁的CAS尝试获取锁资源，如果拿不到锁资源，才会挂起线程。synchronized在jdk1.6以后提供了锁升级的优化
-
无锁、匿名偏向：当前对象没有作为锁存在
-
偏向锁：如果当前锁资源只有一个线程在频繁的获取和释放，当这个线程过来，只需要判断当前指向的线程是否是当前线程，
-
如果是，则直接拿着锁资源执行，
-
如果不是，则基于CAS的方式尝试将偏向锁指向当前线程，如果获取不到则触发锁升级，升级为轻量级锁（偏向锁状态出现了锁竞争的情况）
-
-
轻量级锁：会采用自旋锁的方式去频繁的采用CAS的形式获取锁资源（采用的是自适应自旋锁）
-
如果成功获取到，拿着锁资源走
-
如果自旋了一段次数，没有拿到锁资源，锁升级，升级为重量级锁
-
-
重量级锁：最传统的synchronized的方式，拿不到锁资源，就挂起当前线程（用户态&内核态）
2.3 synchronized实现原理
synchronized是基于对象实现的，new一个对象后，在堆内存中开辟一个空间，存放对象头、实例数据、对象填充，对象头内存放：markword、classPoint等信息，对象的锁信息都存放在MarkWord中。
markword的信息如下图所示：
2.4 synchronized的锁升级
导入以下依赖，用于查看对象头的markword的信息
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>8.9</version>
</dependency>调用代码：
public static void main(String[] args){
Object o = new Object();
System.out.println(ClassLayout.parseInstance(o).toPrintable());
}偏向锁在升级为轻量级锁时，会涉及到偏向锁撤销，需要等到一个安全点（STW），才可以做偏向锁撤销，在明知道有并发情况，就可以选择不开启偏向锁，或者设置偏向锁延迟开启。因为JVM在启动时需要加载大量的class文件到内存中，这个操作会涉及到synchronized的使用，为了避免出现偏向锁撤销操作，JVM启动时会有一个5s的延迟。
整个锁升级状态的改变
2.5 重量级锁的底层ObjectMonitor
通过openjdk官网查看ObjectMonitor的源码，主要看ObjectMonitor的hpp、cpp两个文件
ObjectMonitor.hpp地址：
jdk8u/jdk8u/hotspot: 69087d08d473 src/share/vm/runtime/objectMonitor.hpp
ObjectMonitor() {
_header = NULL; // 存储markword
_count = 0; // 竞争锁的线程个数
_waiters = 0, // wait的线程个数
_recursions = 0; // synchronized锁重入的次数
_object = NULL;
_owner = NULL; // 持有锁的线程
_WaitSet = NULL; // 保存wait的线程信息，双向链表
_WaitSetLock = 0 ;
_Responsible = NULL ;
_succ = NULL ;
_cxq = NULL ; //获取锁资源失败后，线程放到当前的单向链表中
FreeNext = NULL ;
_EntryList = NULL ; //_cxq以及被唤醒的_WaitSet的线程，在一定机制下会放在EntryList中
_SpinFreq = 0 ;
_SpinClock = 0 ;
OwnerIsThread = 0 ;
_previous_owner_tid = 0;
}ObjectMonitor.cpp（具体的逻辑实现）地址：
jdk8u/jdk8u/hotspot: 69087d08d473 src/share/vm/runtime/objectMonitor.cpp
int ObjectMonitor::TryLock (Thread * Self) {
for (;;) {
// 拿到持有锁的线程
void * own = _owner ;
// 如果有线程持有锁， 直接返回0
if (own != NULL) return 0 ;
// 没有线程持有锁，继续，cmpxchg_ptr这个指令就是底层CAS的实现
if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
// Either guarantee _recursions == 0 or set _recursions = 0.
assert (_recursions == 0, "invariant") ;
assert (_owner == Self, "invariant") ;
// CONSIDER: set or assert that OwnerIsThread == 1
// 成功获取锁资源
return 1 ;
}
// The lock had been free momentarily, but we lost the race to the lock.
// Interference -- the CAS failed.
// We can either return -1 or retry.
// Retry doesn't make as much sense because the lock was just acquired.
if (true) return -1 ;
}
}bool ObjectMonitor::try_enter(Thread* THREAD) {
// 当前线程不是持有锁的线程
if (THREAD != _owner) {
//判断当前持有锁的线程是不是当前线程，说明这是轻量级锁刚刚升级过来的
if (THREAD->is_lock_owned ((address)_owner)) {
assert(_recursions == 0, "internal state error");
_owner = THREAD ;
_recursions = 1 ;
OwnerIsThread = 1 ;
return true;
}
// CAS操作尝试获取锁资源
if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
// 没拿到锁
return false;
}
// 拿到锁了
return true;
} else {
// 锁重入操作
_recursions++;
return true;
}
}3、深入ReentrantLock
3.1 ReentrantLock与synchronized的区别
-
ReentrantLock是个类，synchronized是个关键字
-
都是在jvm层面实现互斥锁的方式
-
若竞争激烈，推荐使用ReentrantLock去实现，不存在锁升级的概念
-
ReentrantLock基于AQS实现，synchronized重量级锁基于ObjectMonitor实现
-
ReentrantLock的功能比synchronized更全面
-
ReentrantLock支持公平锁以及非公平锁
-
ReentrantLock可以指定锁等待的时间
-
3.2 AQS概述
AQS全称AbstractQueuedSynchronizer，它是JUC下的一个基类，AQS中提供了一个由volatile修饰的，并采用CAS修改的int类型的state变量，其次AQS中维护了一个Node对象双向链表（有头尾节点）。
3.2.1 加锁流程概述
下图基于非公平锁的流程
3.2.2 三种加锁的源码分析
lock方法
- 公平与非公平锁，都会执行acquire(),不同的是非公平锁会先执行CAS去竞争锁资源
非公平锁先执行如下代码
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
} // 公平与非公平均执行如下代码
public final void acquire(int arg) {
// 再次查看当前线程是否可以尝试获取锁资源
if (!tryAcquire(arg) &&
// 没有拿到锁资源，
// addWaiter(Node.EXCLUSIVE) 将当前线程封装为互斥锁的Node节点，同时插入到双向链表的结尾
// acquireQueued方法：
// 查看是否是第一个排队的节点，如果是可以再次尝试获取锁资源，如果长时间拿不到，挂起线程
// 如果不是第一个节点，尝试挂起线程
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
// 中断线程操作
selfInterrupt();
}- tryAcquire方法
// 非公平锁的实现
final boolean nonfairTryAcquire(int acquires) {
// 获取当前线程
final Thread current = Thread.currentThread();
// 获取state属性
int c = getState();
// 如果为0，之前持有锁的线程释放了线程
if (c == 0) {
// 再次去抢锁资源，拿到锁就返回true
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 有线程持有锁资源，判断持有锁的线程是否是当前线程，如果是，证明是锁重入操作
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
// 超过了int的最大正数，加一后变为负数，抛出异常：锁重入次数达到最大值
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 将state加一
setState(nextc);
return true;
}
return false;
}// 公平锁的实现
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 如果为0，之前持有锁的线程释放了线程
if (c == 0) {
// 查看是否有线程在AQS的双向队列中排队，返回false代表没人排队，如我排在第一名则返回false，代表我可以去抢锁
if (!hasQueuedPredecessors() &&
// 再次去抢锁资源，拿到锁就返回true
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 有线程持有锁资源，判断持有锁的线程是否是当前线程，如果是，证明是锁重入操作
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}addWaiter方法，将当前没有拿到锁资源的线程扔到AQS队列中去排队
private Node addWaiter(Node mode) {
// mode传入的是互斥锁
Node node = new Node(mode);
for (;;) {
Node oldTail = tail;
if (oldTail != null) {
// 将当前节点指向尾节点
node.setPrevRelaxed(oldTail);
// 以CAS的方式将当前线程设置为尾节点
if (compareAndSetTail(oldTail, node)) {
oldTail.next = node;
return node;
}
} else {
// 不存在尾节点，初始化队列
initializeSyncQueue();
}
}
}
Node(Node nextWaiter) {
this.nextWaiter = nextWaiter;
//将当前线程封装为node
THREAD.set(this, Thread.currentThread());
}acquireQueued方法，当前线程是否还能再次尝试获取锁资源，如果不能尝试获取锁资源或者拿不到锁资源，尝试将线程挂起
// 当前没有拿到锁资源，并且到AQS排队之后触发的方法，这里不考虑中断操作
final boolean acquireQueued(final Node node, int arg) {
boolean interrupted = false;
try {
for (;;) {
// 拿到当前节点的前置节点
final Node p = node.predecessor();
// 若前置节点是头节点，则再次执行tryAcquire方法尝试获取锁资源，
// 如果拿到了锁资源，将当前节点设置为头节点，并取消前置节点
// 同时将前置节点的下一个节点置空，跳出循环
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return interrupted;
}
// 如果前置节点不是头节点或者尝试获取锁资源失败，查看能否挂起线程
if (shouldParkAfterFailedAcquire(p, node))
interrupted |= parkAndCheckInterrupt();
}
} catch (Throwable t) {
cancelAcquire(node);
if (interrupted)
selfInterrupt();
throw t;
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 状态值为-1，节点状态正常
if (ws == Node.SIGNAL)
return true;
// 节点状态为1 ，进行循环便利，找当前节点的前置节点小于1的，将指针指向这个节点
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 状态值为0，需要将前置节点状态值改为-1
pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
}
return false;
}tryLock方法
tryLock()：如果当前线程已经持有该锁，那么持有计数将增加1，并且该方法返回true。 如果锁被另一个线程持有，那么这个方法将立即返回值false。
public boolean tryLock() {
// 调用的是非公平锁的操作
return sync.nonfairTryAcquire(1);
}tryLock(long timeout, TimeUnit unit)：
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
//线程中断的标记位，如果是true直接抛异常
if (Thread.interrupted())
throw new InterruptedException();
//tryAcquire 公平与非公平两种方式，如果拿锁成功直接返回，否则执行doAcquireNanos
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果等待时间小于0，直接返回false，拿锁失败
if (nanosTimeout <= 0L)
return false;
// 设置结束时间
final long deadline = System.nanoTime() + nanosTimeout;
// 添加排它锁到等待队列（AQS队列）
final Node node = addWaiter(Node.EXCLUSIVE);
try {
for (;;) {
final Node p = node.predecessor();
// 当前节点的上一个节点如果是头节点，则尝试获取锁资源，获取成功设置head为当前节点，将上一节点的指针指向空，GC回收上一节点
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return true;
}
// 当前节点没有拿到锁资源，查看是否到达结束时间
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L) {
// 超时 取消获取锁资源
cancelAcquire(node);
return false;
}
// 如果前置节点不是头节点或者尝试获取锁资源失败，查看能否挂起线程，超时时长大于旋转的阈值（1000ms）
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
// 挂起线程剩余时间
LockSupport.parkNanos(this, nanosTimeout);
// 查看是线程中断唤醒的，还是时间到了唤醒的
if (Thread.interrupted())
// 说明是中断唤醒的
throw new InterruptedException();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}private void cancelAcquire(Node node) {
// 当前节点已经null 直接返回
if (node == null)
return;
// 设置当前节点的线程为null
node.thread = null;
//寻找当前节点的上面节点，直到找到节点状态<=0的，将当前节点的前置指针指向满足条件的节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
Node predNext = pred.next;
// 设置当前节点的状态为取消（1）
node.waitStatus = Node.CANCELLED;
// 如果当前节点是尾节点并且经过CAS后依然没有拿到锁资源（替换尾节点成功）
if (node == tail && compareAndSetTail(node, pred)) {
// 前置节点的后置节点进行CAS。
pred.compareAndSetNext(predNext, null);
} else {
int ws;
// 非head的后继节点
if (pred != head &&
// 拿到上一个节点的状态并且判断是否为-1，如果不是-1并且<=0，就改成-1
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
pred.thread != null) {
// 前继节点是有效节点
Node next = node.next;
if (next != null && next.waitStatus <= 0)
// 取消当前节点的前后指针，并建立前后指针新的关系
pred.compareAndSetNext(predNext, next);
} else {
//唤醒后继节点操作
unparkSuccessor(node);
}
// GC回收
node.next = node; // help GC
}
}lockInterruptibly方法
//lockInterruptibly() 与trylock(time,unit)唯一不同的地方是throw new InterruptedException();
// 拿不到锁资源就死等，等到锁资源就唤醒，中断唤醒就抛异常
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 中断唤醒抛异常
throw new InterruptedException();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}
// 这个方法可以确定当前线程是被中断唤醒的还是被正常唤醒的，中断返回true，正常返回false；
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}3.2.3 释放锁源码分析
unlock()方法
如果当前线程不持有该锁，则在释放锁时抛出异常IllegalMonitorStateException，否则执行如下代码逻辑
// unlock方法执行的内容
public final boolean release(int arg) {
// 主方法 返回true代表锁释放干净，否则返回false
if (tryRelease(arg)) {
Node h = head;
// 判断头节点不为null并且节点状态不等于0，则唤醒有效的后继节点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
// 直接放回false，释放锁失败
return false;
}
protected final boolean tryRelease(int releases) {
// 获取state值并减1
int c = getState() - releases;
// 判断当前线程是否持有锁
if (Thread.currentThread() != getExclusiveOwnerThread())
// 如果不持有锁则直接抛出异常
throw new IllegalMonitorStateException();
// 设置空闲为null
boolean free = false;
// 判断state是否为0，为0则表示锁释放干净，不为0，则表示重入锁未释放干净
if (c == 0) {
// 释放干净后设置free为true，代表锁已经释放干净
free = true;
// 设置持有锁的线程为null
setExclusiveOwnerThread(null);
}
// 设置state为当前值
setState(c);
return free;
}3.3 AQS中常见的问题
-
之所以有一个虚拟的head节点是为了方便后续的操作，这个head节点可以不需要，如果head的状态不是-1，就不需要唤醒后继节点；否则找到head的next节点，如果为null，或是取消了，此时需要遍历双向链表，从后往前遍历，找到离head最近的节点。head节点并不能规避重复唤醒的操作，重复唤醒的操作对系统并不会产生问题。
-
AQS使用双向链表，为了更方便的操作，当一个节点取消时，可以更方便的修改前后的指针指向，从而避免循环遍历。
4 ConditionObject
4.1 ConditionObject 介绍
ReentrantLock提供了await和signal方法来实现类似于wait和notify的功能，前提是必须持有锁资源
package com.bobo.jdk.lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
System.out.println("挂起线程");
lock.lock();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
try {
condition.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("唤醒线程，持有锁");
}).start();
Thread.sleep(100);
lock.lock();
System.out.println("主线程等待5s后拿到锁资源，子线程执行await方法");
condition.signal();
System.out.println("主线程唤醒子线程");
lock.unlock();
}
}
4.2 ConditionObject 源码分析
lock锁中可以有多个ConditionObject 对象，并且互不影响
ConditionObject使用单向链表
核心属性：
private transient Node firstWaiter；
private transient Node lastWaiter;await方法前置分析
-
判断是否中断，则不做任何操作
-
如果没有中断，则封装为node放在Condition队列中（单向链表）
-
一次性释放锁资源
-
如果没有在AQS队列中，则执行挂起操作
public final void await() throws InterruptedException {
// 线程中断直接抛出异常
if (Thread.interrupted())
throw new InterruptedException();
// 添加到condition队列中
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
int interruptMode = 0;
// 是否在aqs队列中
while (!isOnSyncQueue(node)) {
// 挂起线程
LockSupport.park(this);
// 省略
}
// 省略
}
// 线程挂起前添加到contidion单向链表中
private Node addConditionWaiter() {
// 未持有锁，抛异常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node t = lastWaiter;
// 如果尾节点不为null，并且尾节点的状态不等于-2
if (t != null && t.waitStatus != Node.CONDITION) {
// 干掉取消的尾节点
unlinkCancelledWaiters();
// 获取新的尾节点
t = lastWaiter;
}
// 构建当前线程的node，并设置状态为-2
Node node = new Node(Node.CONDITION);
if (t == null)
firstWaiter = node;
else
// 设置尾节点指向当前节点
t.nextWaiter = node;
// 设置当前节点为尾节点
lastWaiter = node;
return node;
}
private void unlinkCancelledWaiters() {
Node t = firstWaiter;
Node trail = null;
while (t != null) {
Node next = t.nextWaiter;
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
if (trail == null)
firstWaiter = next;
else
trail.nextWaiter = next;
if (next == null)
lastWaiter = trail;
}
else
trail = t;
t = next;
}
}
// 一次性释放锁资源
final int fullyRelease(Node node) {
try {
int savedState = getState();
if (release(savedState))
return savedState;
throw new IllegalMonitorStateException();
} catch (Throwable t) {
node.waitStatus = Node.CANCELLED;
throw t;
}
}signal唤醒线程的核心方法
// 线程挂起后，可以通过signal唤醒
public final void signal() {
// 在执行ReentrantLock的方法中，如果当前signal的线程没有持有锁资源，则直接抛出异常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 拿到排在首位的等待节点node
Node first = firstWaiter;
// 如果没有排队的，则不需要唤醒，否则进行唤醒操作
if (first != null)
doSignal(first);
}
// 执行唤醒操作
private void doSignal(Node first) {
// 先执行循环，
do {
// 获取第二个节点，并将其赋值给firstWaiter
// 如果第二个节点为null，则将lastWaiter值为null，说明在Condition队列中只有一个节点
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
// 设置当前节点脱离Condition队列，并将first节点的后置节点指向null
first.nextWaiter = null;
//
} while (!transferForSignal(first) &&
// 如果后续节点还有，则往后面继续唤醒，如果没有，则退出循环
(first = firstWaiter) != null);
}
// 准备唤醒在Condition队列中的节点
final boolean transferForSignal(Node node) {
// 将node的状态由-2 改为0 ，代表要扔到AQS队列中
if (!node.compareAndSetWaitStatus(Node.CONDITION, 0))
// 唤醒失败
return false;
// 将当前node 扔到AQS队列，返回的p是当前node的上一个节点
Node p = enq(node);
int ws = p.waitStatus;
// 如果ws>0说明这个node被取消了，如果ws的状态不是取消状态，则将prev的状态改为-1
if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL))
// 如果prev节点已经被取消了，可能导致当前节点无法被唤醒
// 立即唤醒当前节点，基于acquireQueued方法，让当前节点找到一个正常的prev节点，挂起线程
// 如果上一个节点正常，但是CAS修改prev失败了，证明prev因为并发原因导致状态改变，基于acquireQueued方法，让当前节点找到一个正常的prev节点
LockSupport.unpark(node.thread);
return true;
}
private Node enq(Node node) {
for (;;) {
Node oldTail = tail;
if (oldTail != null) {
node.setPrevRelaxed(oldTail);
if (compareAndSetTail(oldTail, node)) {
oldTail.next = node;
return oldTail;
}
} else {
initializeSyncQueue();
}
}
}await方法的后置分析
public final void await() throws InterruptedException {
// 省略代码。。。。。。
while (!isOnSyncQueue(node)) {
// 挂起线程
LockSupport.park(this);
// 如果执行到这个位置，则说明线程被唤醒了
//返回值有三种：
//0: 正常signal唤醒，不确定是否在AQS队列中
// -1: 中断唤醒，一定在AQS队列中
//1: signal唤醒，但中断了，一定在AQS队列中
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// node一定在AQS队列
// acquireQueued 获取锁资源
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
// 如果线程在AQS队列中中断了，并且不是THROW_IE状态，设置interruptMode= REINTERRUPT
interruptMode = REINTERRUPT;
// 如果当前node还在Condition单向链表中，则进行脱离操作
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
// interruptMode=0，说明线程在signal后，没被中断过
// interruptMode！=0 ，说明
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
/** Mode meaning to reinterrupt on exit from wait */
private static final int REINTERRUPT = 1;
/** Mode meaning to throw InterruptedException on exit from wait */
private static final int THROW_IE = -1;
private int checkInterruptWhileWaiting(Node node) {
//
return Thread.interrupted() ?
// THROW_IE：代表线程是被interrupt唤醒的，需要抛出异常，
// REINTERRUPT：代表线程是被signal唤醒的，但唤醒之后被中断了
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
// 返回0 说明线程是正常的被signal唤醒，并且没有中断过
0;
}
final boolean transferAfterCancelledWait(Node node) {
// 将node的状态从-2改为0
if (node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
// 说明是CAS成功了，说明线程是中断唤醒的，将node添加到AQS队列中（如果是中断唤醒的，当前node同时存在Condition队列、AQS队列中）
enq(node);
return true;
}
/*
* If we lost out to a signal(), then we can't proceed
* until it finishes its enq(). Cancelling during an
* incomplete transfer is both rare and transient, so just
* spin.
*/
// 判断当前node是否在同步队列中（即AQS队列中）
// signal唤醒的，可能还没有放到AQS队列中，等到signal方法将线程扔到AQS队列中，再继续后续操作
while (!isOnSyncQueue(node))
// 如果不在AQS队列中，则线程让步，等node加入AQS后，再继续操作
Thread.yield();
return false;
}
final boolean isOnSyncQueue(Node node) {
// 如果线程状态为-2，则肯定不在AQS队列中
// 如果前置节点为null，则肯定不在AQS队列中
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 说明在AQS队列上
if (node.next != null) // If has successor, it must be on queue
return true;
/*
* node.prev can be non-null, but not yet on queue because
* the CAS to place it on queue can fail. So we have to
* traverse from tail to make sure it actually made it. It
* will always be near the tail in calls to this method, and
* unless the CAS failed (which is unlikely), it will be
* there, so we hardly ever traverse much.
*/
// 如果上述都没有确定node在AQS队列上，则在AQS队列中从尾到头查询是否存在node
return findNodeFromTail(node);
}
private boolean findNodeFromTail(Node node) {
// We check for node first, since it's likely to be at or near tail.
// tail is known to be non-null, so we could re-order to "save"
// one null check, but we leave it this way to help the VM.
for (Node p = tail;;) {
if (p == node)
return true;
if (p == null)
return false;
p = p.prev;
}
}
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
// 如果是中断唤醒的await，直接抛出异常
if (interruptMode == THROW_IE)
throw new InterruptedException();
// 如果被中断过，则执行selfInterrupt方法
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
static void selfInterrupt() {
// 设置中断标记位
Thread.currentThread().interrupt();
}awaitNanos()方法
// 到达指定时间后，自动唤醒
public final long awaitNanos(long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
final long deadline = System.nanoTime() + nanosTimeout;
long initialNanos = nanosTimeout;
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
// 时间小于等于0，不进行操作
if (nanosTimeout <= 0L) {
// 将节点放入AQS队列中
transferAfterCancelledWait(node);
break;
}
// nanosTimeout大于1000ns，则挂起相应时间的线程
if (nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
LockSupport.parkNanos(this, nanosTimeout);
// 唤醒逻辑
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
// 计算剩余时间
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
long remaining = deadline - System.nanoTime(); // avoid overflow
return (remaining <= initialNanos) ? remaining : Long.MIN_VALUE;
}signalAll方法
// 将Condition队列中的全部节点唤醒，并扔到AQS队列中
private void doSignalAll(Node first) {
// 去掉头尾node
lastWaiter = firstWaiter = null;
do {
// 拿到当前节点的next节点
Node next = first.nextWaiter;
// 断开当前节点的next节点引用
first.nextWaiter = null;
// 修改node状态，并将当前节点同步到AQS队列中
transferForSignal(first);
// 指向下一个节点
first = next;
// 循环遍历节点
} while (first != null);
}4、深入ReentrantReadWriteLock
4.1 为什么出现读写锁
synchronized和reentrantLock都是互斥锁
如果一个操作是读多写少，采用上述操作，效率是很低的，这种情况可以采用ReentrantReadWriteLock去实现，原理是读读之间是非互斥的，即并发执行，如果是写操作，则还是互斥的
4.2 读写锁原理
依然是基于AQS操作的，还是对state进行操作，拿到锁就去执行，否则则在AQS队列中排队
读锁操作：基于state的高16位进行操作
写锁操作：基于state的低16位进行操作
ReentrantReadWriteLock依然是可重入锁，写锁操作与ReentrantLock一致，但读锁操作是共享锁，所以同一时间会有多个线程持有读锁资源，为了去记录锁重入的次数，因此每个读线程会有一个ThreadLocal中记录锁重入的次数
4.3 写锁的分析
4.3.1 写锁的加锁流程
-
写锁线程来竞争锁资源
-
写线程会通过tryAcquire来获取锁资源（公平锁&非公平锁）
-
获取state值，拿到低16bit的值
-
如果state不为0
- 判断是否是锁重入操作，判断当前持有写锁的线程是否是当前线程
-
如果state为0
-
如果是公平锁，查看队列是否有排队的
-
如果是非公平锁，直接抢锁
-
-
如果拿到锁资源，直接返回，如果没有拿到，则去队列中排队
4.3.2 写锁的加锁源码分析
// 写锁的加锁入口
public void lock() {
sync.acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// 写锁实现
protected final boolean tryAcquire(int acquires) {
/*
* Walkthrough:
* 1. If read count nonzero or write count nonzero
* and owner is a different thread, fail.
* 2. If count would saturate, fail. (This can only
* happen if count is already nonzero.)
* 3. Otherwise, this thread is eligible for lock if
* it is either a reentrant acquire or
* queue policy allows it. If so, update state
* and set owner.
*/
Thread current = Thread.currentThread();
int c = getState();
// 得到state低16位的值
int w = exclusiveCount(c);
// 判断是否有线程持有锁资源
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
// 当前没有线程持有写锁，读写互斥，直接return false
// 有线程哪有写锁，但不是当前线程，不是锁重入，直接返回false
if (w == 0 || current != getExclusiveOwnerThread())
return false;
// 当前线程持有写锁，锁重入
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Reentrant acquire
// 没有超过锁重入的次数，设置state+1
setState(c + acquires);
return true;
}
// 尝试获取锁资源，非公平锁writerShouldBlock直接返回false，如果是公平锁，需要查看是否有排队的，如果是
if (writerShouldBlock() ||
// 进行CAS操作
!compareAndSetState(c, c + acquires))
return false;
// 拿锁成功了，设置占有互斥锁的线程
setExclusiveOwnerThread(current);
return true;
}4.3.3 写锁的释放锁源码分析
释放流程与ReentrantLock一致，区别是判断低16位的值
// 释放锁入口
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
// 判断当前线程是否持有写锁
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 判断低16bit
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}4.4 读锁的分析
4.4.1 读锁的加锁流程
4.4.2 读锁加锁源码分析
public void lock() {
sync.acquireShared(1);
}
// 读锁加锁的方法入口
public final void acquireShared(int arg) {
// 竞争锁资源
if (tryAcquireShared(arg) < 0)
// 没拿到锁资源去排队
doAcquireShared(arg);
}
// 读锁竞争锁资源
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
// 拿到state的低16位，判断是否为0，不为0 有写锁占用锁资源
if (exclusiveCount(c) != 0 &&
// 并且当前线程不占有锁资源
getExclusiveOwnerThread() != current)
// 写锁被其他线程占用，无法拿锁，去排队
return -1;
// 获取读锁信息，state的高16位
int r = sharedCount(c);
// 公平锁：查看队列是否有排队的，有排队的直接返回
// 非公平锁：没有排队的直接抢，有排队的但读锁不需要排队，如果出现这个情况，应该是写锁资源刚刚释放，后续node还没来及拿读锁资源，当前竞争的读线程可以直接获取
if (!readerShouldBlock() &&
// 判断持有锁的临界值
r < MAX_COUNT &&
// CAS修改state并对高16位+1
compareAndSetState(c, c + SHARED_UNIT)) {
// 锁重入的源码操作----------
// =0，当前是第一个拿到锁资源的线程
if (r == 0) {
// 设置缓存
firstReader = current;
firstReaderHoldCount = 1;
// 当前线程是否是第一个拿到读锁资源的线程
} else if (firstReader == current) {
// 重入次数+1
firstReaderHoldCount++;
} else {
// 不是第一个获取读锁资源的线程
// 先获取最后一个拿到读锁资源的线程
HoldCounter rh = cachedHoldCounter;
// 判断当前线程是否是最后一个拿到读锁资源的线程
if (rh == null ||
rh.tid != LockSupport.getThreadId(current))
// 如果当前线程不是，设置当前线程为cachedHoldCounter
cachedHoldCounter = rh = readHolds.get();
// 当前线程是之前的cachedHoldCounter
else if (rh.count == 0)
// 将当前线程的重入信息设置到readHolds中（ThreadLocal）
readHolds.set(rh);
rh.count++;
}
// 锁重入的源码操作end----------
return 1;
}
return fullTryAcquireShared(current);
}
// 非公平锁的判断逻辑
final boolean apparentlyFirstQueuedIsExclusive() {
Node h, s;
return (h = head) != null && // head 为null 可以直接抢占锁资源
(s = h.next) != null && // head的next为null，可以直接抢占锁资源
!s.isShared() && // 如果next是共享锁，可以直接抢占锁资源
s.thread != null; // next的线程为null 可以直接抢占锁资源
}
// 读锁竞争的循环判断
final int fullTryAcquireShared(Thread current) {
// 生命当前线程的锁重入次数
HoldCounter rh = null;
for (;;) {
int c = getState();
// 当前如果有写锁占用锁资源并且不是当前线程，返回-1 走排队策略
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
// else we hold the exclusive lock; blocking here
// would cause deadlock.
// 查看当前是否可以尝试竞争锁资源，（公平锁、分公平锁）
} else if (readerShouldBlock()) {
// 在处理ThreadLocal的内存泄漏问题
if (firstReader == current) {
// 如果当前线程是firstReader，什么都不做
} else {
// 第一次进来肯定是null
if (rh == null) {
//拿到最后一个获取读锁的线程
rh = cachedHoldCounter;
//如果没有
if (rh == null ||
rh.tid != LockSupport.getThreadId(current)) {
// 从自己的ThreadLocal中获取重入计数器
rh = readHolds.get();
if (rh.count == 0)
// 计数器为0 说明之前没有拿到过锁资源，则remove掉，避免内存泄漏
readHolds.remove();
}
}
// 直接返回-1
if (rh.count == 0)
return -1;
}
}
// 判断重入次数是否超过阈值
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// CAS尝试获取锁资源
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
if (rh == null)
rh = cachedHoldCounter;
if (rh == null ||
rh.tid != LockSupport.getThreadId(current))
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}// 读锁的加锁源码 后续处理
private void doAcquireShared(int arg) {
// 声明node 类型为共享锁，扔到AQS中排队
final Node node = addWaiter(Node.SHARED);
boolean interrupted = false;
try {
for (;;) {
final Node p = node.predecessor();
// 如果是head节点，则直接执行tryAcquireShared方法
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
// 拿到读锁资源 的后续处理
setHeadAndPropagate(node, r);
p.next = null; // help GC
return;
}
}
// 找到prev有效节点，将状态设置为-1 挂起当前线程
if (shouldParkAfterFailedAcquire(p, node))
interrupted |= parkAndCheckInterrupt();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
} finally {
if (interrupted)
selfInterrupt();
}
}
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
// 第一个判断是在信号量中处理JDK1.5的bug
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
// 拿到当前node的next节点，如果next是共享锁，则直接唤醒next节点
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}4.4.3 读锁的释放锁源码分析
public void unlock() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
// 处理state的值以及可重入的内容
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
// 如果是firstReader 直接设置缓存
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} else {
// 获取cachedHoldCounter
HoldCounter rh = cachedHoldCounter;
if (rh == null ||
rh.tid != LockSupport.getThreadId(current))
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
--rh.count;
}
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
// Releasing the read lock has no effect on readers,
// but it may allow waiting writers to proceed if
// both read and write locks are now free.
return nextc == 0;
}
}
// 处理AQS队列
private void doReleaseShared() {
for (;;) {
Node h = head;
// 有排队的
if (h != null && h != tail) {
// head状态
int ws = h.waitStatus;
// 是否为-1，=-1说明后面有线程挂起，则基于CAS，将head状态从-1改为0，执行唤醒操作
if (ws == Node.SIGNAL) {
if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
continue;
// 唤醒后续操作
unparkSuccessor(h);
// 这里不是给读写锁准备的，信号量里详细说明
} else if (ws == 0 &&
!h.compareAndSetWaitStatus(0, Node.PROPAGATE))
continue; // loop on failed CAS
}
// 跳出逻辑
if (h == head) // loop if head changed
break;
}
}
// 唤醒后续节点操作
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
node.compareAndSetWaitStatus(ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node p = tail; p != node && p != null; p = p.prev)
if (p.waitStatus <= 0)
s = p;
}
if (s != null)
LockSupport.unpark(s.thread);
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
