并发-AQS应用之Lock

AQS应用之Lock

Java并发编程核心在于java.concurrent.util包而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS，AQS定义了一套多线程访问共享资源 的同步器框架，是一个依赖状态(state)的同步器。

ReentrantLock

ReentrantLock是一种基于AQS框架的应用实现，是JDK中的一种线程并发访问的同步手段，它的功能类似于synchronized是一种互斥锁，可以保证线程安全。而且它具有比synchronized更多的特性，比如它支持手动加锁与解锁，支持加锁的公平性。

ReentrantLock如何实现synchronized不具备的公平与非公平性呢？
在ReentrantLock内部定义了一个Sync的内部类，该类继承AbstractQueuedSynchronized，对该抽象类的部分方法做了实现；并且还定义了两个子类：

• 1、FairSync 公平锁的实现
• 2、NonfairSync 非公平锁的实现

这两个类都继承自Sync，也就是间接继承了AbstractQueuedSynchronized，所以这一个ReentrantLock同时具备公平与非公平特性。
上面主要涉及的设计模式：模板模式-子类根据需要做具体业务实现

AQS具备特性

• 阻塞等待队列
• 共享/独占
• 公平/非公平
• 可重入
• 允许中断

除了Lock外，Java.concurrent.util当中同步器的实现如Latch,Barrier,BlockingQueue等， 都是基于AQS框架实现

• 一般通过定义内部类Sync继承AQS
• 将同步器所有调用都映射到Sync对应的方法

AQS内部维护属性volatile int state (32位)

• state表示资源的可用状态

State三种访问方式
getState()、setState()、compareAndSetState()

AQS定义两种资源共享方式

• Exclusive-独占，只有一个线程能执行，如ReentrantLock
• Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch

AQS定义两种队列

• 同步等待队列
• 条件等待队列

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/ 唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

• isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
• tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
• tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
• tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
• tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

同步等待队列

AQS当中的同步等待队列也称CLH队列，CLH队列是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列，是FIFO先入先出线程等待队列，Java中的CLH 队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制。

条件等待队列

Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备时，这些等待线程才会被唤醒，从而重新争夺锁

AQS源码分析

```sql
1public abstract class AbstractQueuedSynchronizer
2extends AbstractOwnableSynchronizer
3implements java.io.Serializable {
4private static final long serialVersionUID = 737398497257241469 1L;
5
6	/**
7* Creates a new {@code AbstractQueuedSynchronizer} instance
8* with initial synchronization state of zero.
9	*/
10	protected AbstractQueuedSynchronizer() { }
11
12	/**
13	* Wait queue node class.
14	*
15* 不管是条件队列，还是CLH等待队列
16* 都是基于Node类
17	*
18* AQS当中的同步等待队列也称CLH队列，CLH队列是Craig、Landin、Hagers ten三人
19* 发明的一种基于双向链表数据结构的队列，是FIFO先入先出线程等待队列，
Java中的
20* CLH队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制。
21	*/
22	static final class Node {
23	/**
24	* 标记节点未共享模式

25	* */
26	static final Node SHARED = new Node();
27	/**
28	* 标记节点为独占模式
29	*/
30	static final Node EXCLUSIVE = null;
31
32	/**
33	* 在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待
34	* */
35	static final int CANCELLED = 1;
36	/**
37* 后继节点的线程处于等待状态，而当前的节点如果释放了同步状态或者被取消，
38* 将会通知后继节点，使后继节点的线程得以运行。
39	*/
40	static final int SIGNAL = ‐1;
41	/**
42* 节点在等待队列中，节点的线程等待在Condition上，当其他线程对Condit ion调用了signal()方法后，
43* 该节点会从等待队列中转移到同步队列中，加入到同步状态的获取中
44	*/
45	static final int CONDITION = ‐2;
46	/**
47	* 表示下一次共享式同步状态获取将会被无条件地传播下去
48	*/
49	static final int PROPAGATE = ‐3;
50
51	/**
52	* 标记当前节点的信号量状态 (1,0,‐1,‐2,‐3)5种状态
53* 使用CAS更改状态，volatile保证线程可见性，高并发场景下，
54* 即被一个线程修改后，状态会立马让其他线程可见。
55	*/
56	volatile int waitStatus;
57
58	/**

59	* 前驱节点，当前节点加入到同步队列中被设置
60	*/
61	volatile Node prev;
62
63	/**
64	* 后继节点
65	*/
66	volatile Node next;
67
68	/**
69	* 节点同步状态的线程
70	*/
71	volatile Thread thread;
72
73	/**
74* 等待队列中的后继节点，如果当前节点是共享的，那么这个字段是一个SHAR ED常量，
75* 也就是说节点类型(独占和共享)和等待队列中的后继节点共用同一个字段。
76	*/
77	Node nextWaiter;
78
79	/**
80	* Returns true if node is waiting in shared mode.
81	*/
82final boolean isShared() {
83return nextWaiter == SHARED;
84	}
85
86	/**
87	* 返回前驱节点
88	*/
89final Node predecessor() throws NullPointerException {
90Node p = prev;
91if (p == null)
92throw new NullPointerException();

93else
94return p;
95	}
96//空节点，用于标记共享模式
97Node() { // Used to establish initial head or SHARED marker
98	}
99//用于同步队列CLH
100Node(Thread thread, Node mode) { // Used by addWaiter
101this.nextWaiter = mode;
102this.thread = thread;
103	}
104//用于条件队列
105Node(Thread thread, int waitStatus) { // Used by Condition
106this.waitStatus = waitStatus;
107this.thread = thread;
108	}
109	}
110
111	/**
112	* 指向同步等待队列的头节点
113	*/
114	private transient volatile Node head;
115
116	/**
117	* 指向同步等待队列的尾节点
118	*/
119	private transient volatile Node tail;
120
121	/**
122	* 同步资源状态
123	*/
124	private volatile int state;
125
126	/**
127	*

128	* @return current state value
129	*/
130protected final int getState() {
131return state;
132	}
133
134protected final void setState(int newState) {
135state = newState;
136	}
137
138	/**
139* Atomically sets synchronization state to the given updated
140* value if the current state value equals the expected value.
141* This operation has memory semantics of a {@code volatile} r ad
142* and write.
143	*
144* @param expect the expected value
145* @param update the new value
146* @return {@code true} if successful. False return indicates hat the actual
147* value was not equal to the expected value.
148	*/
149protected final boolean compareAndSetState(int expect, int up ate) {
150// See below for intrinsics setup to support this
151return unsafe.compareAndSwapInt(this, stateOffset, expect, up ate);
152	}
153
154	// Queuing utilities
155
156	/**
157* The number of nanoseconds for which it is faster to spin
158* rather than to use timed park. A rough estimate suffices
159* to improve responsiveness with very short timeouts.

160	*/
161	static final long spinForTimeoutThreshold = 1000L;
162
163	/**
164	* 节点加入CLH同步队列
165	*/
166	private Node enq(final Node node) {
167	for (;;) {
168Node t = tail;
169if (t == null) { // Must initialize
170//队列为空需要初始化，创建空的头节点
171if (compareAndSetHead(new Node()))
172tail = head;
173} else {
174node.prev = t;
175//set尾部节点
176if (compareAndSetTail(t, node)) {//当前节点置为尾部
177t.next = node; //前驱节点的next指针指向当前节点
178return t;
179	}
180	}
181	}
182	}
183
184	/**
185	* Creates and enqueues node for current thread and given mode
186	*
187* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for s ared
188* @return the new node
189	*/
190private Node addWaiter(Node mode) {
191// 1. 将当前线程构建成Node类型
192Node node = new Node(Thread.currentThread(), mode);
193// Try the fast path of enq; backup to full enq on failure

194	Node pred = tail;	
195	// 2. 1当前尾节点是否为null？	
196	if (pred != null) {	
197	// 2.2 将当前节点尾插入的方式	
198	node.prev = pred;	
199	// 2.3 CAS将节点插入同步队列的尾部	
200	if (compareAndSetTail(pred, node)) {	
201	pred.next = node;	
202	return node;	
203	}	
204	}	
205	enq(node);	
206	return node;	
207	}	
208		
209	/**	
210
y	* Sets head of queue to be node, thus dequeuing. Called only	
211	* acquire methods. Also nulls out unused fields for sake of	G
212	* and to suppress unnecessary signals and traversals.	
213	*	
214	* @param node the node	
215	*/	
216	private void setHead(Node node) {	
217	head = node;	
218	node.thread = null;	
219	node.prev = null;	
220	}	
221		
222	/**	
223	*	
224	*/	
225	private void unparkSuccessor(Node node) {	
226	//获取wait状态	
227	int ws = node.waitStatus;	

228if (ws < 0)
229compareAndSetWaitStatus(node, ws, 0);// 将等待状态waitStatus设置为初始值0
230
231	/**
232* 若后继结点为空，或状态为CANCEL（已失效），则从后尾部往前遍历找到最前的一个处于正常阻塞状态的结点
233* 进行唤醒
234	*/
235Node s = node.next; //head.next = Node1 ,thread = T3
236if (s == null || s.waitStatus > 0) {
237s = null;
238for (Node t = tail; t != null && t != node; t = t.prev)
239if (t.waitStatus <= 0)
240s = t;
241	}
242if (s != null)
243LockSupport.unpark(s.thread);//唤醒线程,T3唤醒
244	}
245
246	/**
247* 把当前结点设置为SIGNAL或者PROPAGATE
248* 唤醒head.next(B节点)，B节点唤醒后可以竞争锁，成功后head‐>B，然后又会唤醒B.next，一直重复直到共享节点都唤醒
249* head节点状态为SIGNAL，重置head.waitStatus‐>0，唤醒head节点线程，唤醒后线程去竞争共享锁
250* head节点状态为0，将head.waitStatus‐>Node.PROPAGATE传播状态，表示需要将状态向后继节点传播
251	*/
252	private void doReleaseShared() {
253	for (;;) {
254Node h = head;
255if (h != null && h != tail) {
256int ws = h.waitStatus;
257if (ws == Node.SIGNAL) {//head是SIGNAL状态
258/* head状态是SIGNAL，重置head节点waitStatus为0，E这里不直接设为N de.PROPAGAT,

259* 是因为unparkSuccessor(h)中，如果ws < 0会设置为0，所以ws先设置为0，再设置为PROPAGATE
260* 这里需要控制并发，因为入口有setHeadAndPropagate跟release两个， 避免两次unpark
261	*/
262if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
263continue; //设置失败，重新循环
264/* head状态为SIGNAL，且成功设置为0之后,唤醒head.next节点线程
265* 此时head、head.next的线程都唤醒了，head.next会去竞争锁，成功后h ead会指向获取锁的节点，
266* 也就是head发生了变化。看最底下一行代码可知，head发生变化后会重新循环，继续唤醒head的下一个节点
267	*/
268	unparkSuccessor(h);
269	/*
270* 如果本身头节点的waitStatus是出于重置状态（waitStatus==0）的，将其设置为“传播”状态。
271* 意味着需要将状态向后一个节点传播
272	*/
273	}
274else if (ws == 0 &&
275!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
276continue; // loop on failed CAS
277	}
278if (h == head) //如果head变了，重新循环
279break;
280	}
281	}
282
283	/**
284	* 把node节点设置成head节点，且Node.waitStatus‐>Node.PROPAGATE
285	*/
286private void setHeadAndPropagate(Node node, int propagate) {
287Node h = head; //h用来保存旧的head节点
288setHead(node);//head引用指向node节点
289/* 这里意思有两种情况是需要执行唤醒操作

290* 1.propagate > 0 表示调用方指明了后继节点需要被唤醒
291* 2.头节点后面的节点需要被唤醒（waitStatus<0），不论是老的头结点还是新的头结点
292	*/
293if (propagate > 0 || h == null || h.waitStatus < 0 ||
294(h = head) == null || h.waitStatus < 0) {
295Node s = node.next;
296if (s == null || s.isShared())//node是最后一个节点或者 node的后继节点是共享节点
297/* 如果head节点状态为SIGNAL，唤醒head节点线程，重置head.waitStat s‐>0
298* head节点状态为0(第一次添加时是0)，设置head.waitStatus‐>Node.PR OPAGATE表示状态需要向后继节点传播
299	*/
300	doReleaseShared();
301	}
302	}
303
304	// Utilities for various versions of acquire
305
306	/**
307* 终结掉正在尝试去获取锁的节点
308* @param node the node
309	*/
310private void cancelAcquire(Node node) {
311// Ignore if node doesn't exist
312if (node == null)
313return;
314
315node.thread = null;
316
317// 剔除掉一件被cancel掉的节点
318Node pred = node.prev;
319while (pred.waitStatus > 0)
320node.prev = pred = pred.prev;
321

322// predNext is the apparent node to unsplice. CASes below wil
323// fail if not, in which case, we lost race vs another cancel
324// or signal, so no further action is necessary.
325Node predNext = pred.next;
326
327// Can use unconditional write instead of CAS here.
328// After this atomic step, other Nodes can skip past us.
329// Before, we are free of interference from other threads.
330node.waitStatus = Node.CANCELLED;
331
332// If we are the tail, remove ourselves.
333if (node == tail && compareAndSetTail(node, pred)) {
334compareAndSetNext(pred, predNext, null);
335} else {
336// If successor needs signal, try to set pred's next‐link
337// so it will get one. Otherwise wake it up to propagate.
338int ws;
339if (pred != head &&
340((ws = pred.waitStatus) == Node.SIGNAL ||
341(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &
342pred.thread != null) {
343Node next = node.next;
344if (next != null && next.waitStatus <= 0)
345compareAndSetNext(pred, predNext, next);
346} else {
347unparkSuccessor(node);
348	}
349
350	node.next = node; // help GC
351	}
352	}
353
354	/**
355	*

356	*/
357private static boolean shouldParkAfterFailedAcquire(Node pred Node node) {
358int ws = pred.waitStatus;
359if (ws == Node.SIGNAL)
360	/*
361	* 若前驱结点的状态是SIGNAL，意味着当前结点可以被安全地park
362	*/
363	return true;
364	if (ws > 0) {
365	/*
366	* 前驱节点状态如果被取消状态，将被移除出队列
367	*/
368do {
369node.prev = pred = pred.prev;
370} while (pred.waitStatus > 0);
371pred.next = node;
372} else {
373	/*
374* 当前驱节点waitStatus为 0 or PROPAGATE状态时
375* 将其设置为SIGNAL状态，然后当前结点才可以可以被安全地park
376	*/
377	compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
378	}
379	return false;
380	}
381
382	/**
383	* 中断当前线程
384	*/
385static void selfInterrupt() {
386Thread.currentThread().interrupt();
387	}
388
389	/**

390* 阻塞当前节点，返回当前Thread的中断状态
391* LockSupport.park 底层实现逻辑调用系统内核功能 pthread_mutex_lo ck 阻塞线程
392	*/
393private final boolean parkAndCheckInterrupt() {
394LockSupport.park(this);//阻塞
395return Thread.interrupted();
396	}
397
398	/**
399	* 已经在队列当中的Thread节点，准备阻塞等待获取锁
400	*/
401	final boolean acquireQueued(final Node node, int arg) {
402	boolean failed = true;
403	try {
404	boolean interrupted = false;
405	for (;;) {//死循环
406final Node p = node.predecessor();//找到当前结点的前驱结点
407if (p == head && tryAcquire(arg)) {//如果前驱结点是头结点，才tr Acquire，其他结点是没有机会tryAcquire的。
408setHead(node);//获取同步状态成功，将当前结点设置为头结点。
409p.next = null; // help GC
410failed = false;
411return interrupted;
412	}
413	/**
414	* 如果前驱节点不是Head，通过shouldParkAfterFailedAcquire判断是否应该阻塞
415	* 前驱节点信号量为‐1，当前线程可以安全被parkAndCheckInterrupt用来阻塞线程
416	*/
417	if (shouldParkAfterFailedAcquire(p, node) &&
418	parkAndCheckInterrupt())
419	interrupted = true;
420	}
421	} finally {

422	if (failed)
423	cancelAcquire(node);
424	}
425	}
426
427	/**
428	* 与acquireQueued逻辑相似，唯一区别节点还不在队列当中需要先进行入队操作
429	*/
430	private void doAcquireInterruptibly(int arg)
431	throws InterruptedException {
432	final Node node = addWaiter(Node.EXCLUSIVE);//以独占模式放入队列尾部
433	boolean failed = true;	
434	try {	
435	for (;;) {	
436	final Node p = node.predecessor();	
437	if (p == head && tryAcquire(arg)) {	
438	setHead(node);	
439	p.next = null; // help GC	
440	failed = false;	
441	return;	
442	}	
443	if (shouldParkAfterFailedAcquire(p,	node) &&
444	parkAndCheckInterrupt())	
445	throw new InterruptedException();	
446	}	
447	} finally {	
448	if (failed)	
449	cancelAcquire(node);	
450	}	
451	}	
452		
453	/**	
454	* 独占模式定时获取	
455	*/	

456private boolean doAcquireNanos(int arg, long nanosTimeout)
457throws InterruptedException {
458if (nanosTimeout <= 0L)
459return false;
460final long deadline = System.nanoTime() + nanosTimeout;
461final Node node = addWaiter(Node.EXCLUSIVE);//加入队列
462boolean failed = true;
463try {
464	for (;;) {
465final Node p = node.predecessor();
466if (p == head && tryAcquire(arg)) {
467setHead(node);
468p.next = null; // help GC
469failed = false;
470return true;
471	}
472nanosTimeout = deadline ‐ System.nanoTime();
473if (nanosTimeout <= 0L)
474return false;//超时直接返回获取失败
475if (shouldParkAfterFailedAcquire(p, node) &&
476nanosTimeout > spinForTimeoutThreshold)
477//阻塞指定时长，超时则线程自动被唤醒
478LockSupport.parkNanos(this, nanosTimeout);
479if (Thread.interrupted())//当前线程中断状态
480throw new InterruptedException();
481	}
482	} finally {
483	if (failed)
484	cancelAcquire(node);
485	}
486	}
487
488	/**
489	* 尝试获取共享锁
490	*/

491private void doAcquireShared(int arg) {
492final Node node = addWaiter(Node.SHARED);//入队
493boolean failed = true;
494try {
495boolean interrupted = false;
496	for (;;) {
497final Node p = node.predecessor();//前驱节点
498if (p == head) {
499int r = tryAcquireShared(arg); //非公平锁实现，再尝试获取锁
500//state==0时tryAcquireShared会返回>=0(CountDownLatch中返回的是1)。
501// state为0说明共享次数已经到了，可以获取锁了
502if (r >= 0) {//r>0表示state==0,前继节点已经释放锁，锁的状态为可被获取
503//这一步设置node为head节点设置node.waitStatus‐>Node.PROPAGATE， 然后唤醒node.thread
504setHeadAndPropagate(node, r);
505p.next = null; // help GC
506if (interrupted)
507selfInterrupt();
508failed = false;
509return;
510	}
511	}
512	//前继节点非head节点，将前继节点状态设置为SIGNAL，通过park挂起nod
节点的线程
513	if (shouldParkAfterFailedAcquire(p, node) &&
514	parkAndCheckInterrupt())
515	interrupted = true;
516	}
517	} finally {
518	if (failed)
519	cancelAcquire(node);
520	}
521	}
522

523	/**
524	* Acquires in shared interruptible mode.
525	* @param arg the acquire argument
526	*/
527private void doAcquireSharedInterruptibly(int arg)
528throws InterruptedException {
529final Node node = addWaiter(Node.SHARED);
530boolean failed = true;
531try {
532	for (;;) {
533	final Node p = node.predecessor();
534	if (p == head) {
535	int r = tryAcquireShared(arg);
536	if (r >= 0) {
537	setHeadAndPropagate(node, r);
538	p.next = null; // help GC
539	failed = false;
540	return;
541	}
542	}
543	if (shouldParkAfterFailedAcquire(p, node) &&
544	parkAndCheckInterrupt())
545	throw new InterruptedException();
546	}
547	} finally {
548	if (failed)
549	cancelAcquire(node);
550	}
551	}
552
553	/**
554	* Acquires in shared timed mode.
555	*
556	* @param arg the acquire argument
557	* @param nanosTimeout max wait time

558	* @return {@code true} if acquired
559	*/
560private boolean doAcquireSharedNanos(int arg, long nanosTimeo t)
561throws InterruptedException {
562if (nanosTimeout <= 0L)
563return false;
564final long deadline = System.nanoTime() + nanosTimeout;
565final Node node = addWaiter(Node.SHARED);
566boolean failed = true;
567try {
568	for (;;) {
569	final Node p = node.predecessor();
570	if (p == head) {
571	int r = tryAcquireShared(arg);
572	if (r >= 0) {
573	setHeadAndPropagate(node, r);
574	p.next = null; // help GC
575	failed = false;
576	return true;
577	}
578	}
579nanosTimeout = deadline ‐ System.nanoTime();
580if (nanosTimeout <= 0L)
581return false;
582if (shouldParkAfterFailedAcquire(p, node) &&
583nanosTimeout > spinForTimeoutThreshold)
584LockSupport.parkNanos(this, nanosTimeout);
585if (Thread.interrupted())
586throw new InterruptedException();
587	}
588	} finally {
589	if (failed)
590	cancelAcquire(node);
591	}

592	}
593
594	// Main exported methods
595
596	/**
597	* 尝试获取独占锁，可指定锁的获取数量
598	*/
599	protected boolean tryAcquire(int arg) { 600	throw new UnsupportedOperationException(); 601	}
602
603	/**
604	* 尝试释放独占锁，在子类当中实现
605	*/
606	protected boolean tryRelease(int arg) { 607	throw new UnsupportedOperationException(); 608	}
609
610	/**
611* 共享式：共享式地获取同步状态。对于独占式同步组件来讲，同一时刻只有一个线程能获取到同步状态，
612* 其他线程都得去排队等待，其待重写的尝试获取同步状态的方法tryAcqui e返回值为boolean，这很容易理解；
613* 对于共享式同步组件来讲，同一时刻可以有多个线程同时获取到同步状态， 这也是“共享”的意义所在。
614* 本方法待被之类覆盖实现具体逻辑
615* 1.当返回值大于0时，表示获取同步状态成功，同时还有剩余同步状态可供其他线程获取；
616	*
617	*	2.当返回值等于0时，表示获取同步状态成功，但没有可用同步状态了；
618
619	*	3.当返回值小于0时，表示获取同步状态失败。
620	*/
621	protected int tryAcquireShared(int arg) { 622	throw new UnsupportedOperationException(); 623	}

624
625	/**
626	* 释放共享锁，具体实现在子类当中实现
627	*/
628	protected boolean tryReleaseShared(int arg) { 629	throw new UnsupportedOperationException(); 630	}
631
632	/**
633	* 当前线程是否持有独占锁
634	*/
635	protected boolean isHeldExclusively() { 636	throw new UnsupportedOperationException(); 637	}
638
639	/**
640	* 获取独占锁
641	*/
642public final void acquire(int arg) {
643//尝试获取锁
644if (!tryAcquire(arg) &&
645acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//独占模式
646selfInterrupt();
647	}
648
649	/**
650	*
651	*/
652public final void acquireInterruptibly(int arg)
653throws InterruptedException {
654if (Thread.interrupted())
655throw new InterruptedException();
656if (!tryAcquire(arg))
657doAcquireInterruptibly(arg);
658	}

659
660	/**
661	* 获取独占锁，设置最大等待时间
662	*/
663public final boolean tryAcquireNanos(int arg, long nanosTimeo t)
664throws InterruptedException {
665if (Thread.interrupted())
666throw new InterruptedException();
667return tryAcquire(arg) ||
668doAcquireNanos(arg, nanosTimeout);
669	}
670
671	/**
672	* 释放独占模式持有的锁
673	*/
674public final boolean release(int arg) {
675if (tryRelease(arg)) {//释放一次锁
676Node h = head;
677if (h != null && h.waitStatus != 0)
678unparkSuccessor(h);//唤醒后继结点
679return true;
680	}
681	return false;
682	}
683
684	/**
685	* 请求获取共享锁
686	*/
687	public final void acquireShared(int arg) {
688	if (tryAcquireShared(arg) < 0)//返回值小于0，获取同步状态失败，排队去；获取同步状态成功，直接返回去干自己的事儿。
689	doAcquireShared(arg);
690	}
691

692

693	/**
694	* Releases in shared mode. Implemented by unblocking one or m re
695	* threads if {@link #tryReleaseShared} returns true.
696	*
697	* @param arg the release argument. This value is conveyed to 698	* {@link #tryReleaseShared} but is otherwise uninterpreted 699	* and can represent anything you like.
700	* @return the value returned from {@link #tryReleaseShared}
701	*/
702	public final boolean releaseShared(int arg) {
703	if (tryReleaseShared(arg)) {
704	doReleaseShared();
705	return true;
706	}
707	return false;
708	}
709
710	// Queue inspection methods
711
712	public final boolean hasQueuedThreads() {
713	return head != tail;
714	}
715
716	public final boolean hasContended() {
717	return head != null;
718	}
719
720	public final Thread getFirstQueuedThread() {
721	// handle only fast path, else relay
722	return (head == tail) ? null : fullGetFirstQueuedThread();
723	}
724
725	/**
726	* Version of getFirstQueuedThread called when fastpath fails

727	*/
728private Thread fullGetFirstQueuedThread() {
729Node h, s;
730Thread st;
731if (((h = head) != null && (s = h.next) != null &&
732s.prev == head && (st = s.thread) != null) || 733	((h = head) != null && (s = h.next) != null && 734	s.prev == head && (st = s.thread) != null)) 735	return st;
736
737Node t = tail;
738Thread firstThread = null;
739while (t != null && t != head) {
740Thread tt = t.thread;
741if (tt != null) 742	firstThread = tt; 743	t = t.prev;
744	}
745	return firstThread;
746	}
747
748	/**
749	* 判断当前线程是否在队列当中
750	*/
751public final boolean isQueued(Thread thread) {
752if (thread == null)
753throw new NullPointerException();
754for (Node p = tail; p != null; p = p.prev)
755if (p.thread == thread)
756return true;
757return false;
758	}
759
760final boolean apparentlyFirstQueuedIsExclusive() {
761Node h, s;

762return (h = head) != null &&
763(s = h.next) != null &&
764!s.isShared() && 765	s.thread != null; 766	}
767
768	/**
769	* 判断当前节点是否有前驱节点
770	*/
771public final boolean hasQueuedPredecessors() {
772Node t = tail; // Read fields in reverse initialization order
773Node h = head;
774Node s;
775return h != t &&
776((s = h.next) == null || s.thread != Thread.currentThread());
777	}
778

779
780	// Instrumentation and monitoring methods
781
782	/**
783	* 同步队列长度
784	*/
785	public final int getQueueLength() {
786	int n = 0;
787	for (Node p = tail; p != null; p = p.prev) {
788	if (p.thread != null)
789	++n;
790	}
791	return n;
792	}
793
794	/**
795	* 获取队列等待thread集合
796	*/

797	public final Collection<Thread> getQueuedThreads() {	
798	ArrayList<Thread> list = new ArrayList<Thread>();	
799	for (Node p = tail; p != null; p = p.prev) {	
800	Thread t = p.thread;	
801	if (t != null)	
802	list.add(t);	
803	}	
804	return list;	
805	}	
806		
807	/**	
808	* 获取独占模式等待thread线程集合	
809	*/	
810	public final Collection<Thread> getExclusiveQueuedThreads()	{
811	ArrayList<Thread> list = new ArrayList<Thread>();	
812	for (Node p = tail; p != null; p = p.prev) {	
813	if (!p.isShared()) {	
814	Thread t = p.thread;	
815	if (t != null)	
816	list.add(t);	
817	}	
818	}	
819	return list;	
820	}	
821		
822	/**	
823	* 获取共享模式等待thread集合	
824	*/	
825	public final Collection<Thread> getSharedQueuedThreads() {	
826	ArrayList<Thread> list = new ArrayList<Thread>();	
827	for (Node p = tail; p != null; p = p.prev) {	
828	if (p.isShared()) {	
829	Thread t = p.thread;	
830	if (t != null)	
831	list.add(t);	

832	}
833	}
834	return list;
835	}
836

837
838	// Internal support methods for Conditions
839
840	/**
841	* 判断节点是否在同步队列中
842	*/
843final boolean isOnSyncQueue(Node node) {
844//快速判断1：节点状态或者节点没有前置节点
845//注：同步队列是有头节点的，而条件队列没有
846if (node.waitStatus == Node.CONDITION || node.prev == null)
847return false;
848//快速判断2：next字段只有同步队列才会使用，条件队列中使用的是nextW iter字段
849if (node.next != null) // If has successor, it must be on que e
850return true;
851//上面如果无法判断则进入复杂判断
852return findNodeFromTail(node);
853	}
854
855	private boolean findNodeFromTail(Node node) {
856	Node t = tail;
857	for (;;) {
858	if (t == node) 859	return true; 860	if (t == null) 861	return false; 862	t = t.prev; 863	}
864	}
865

866	/**
867	* 将节点从条件队列当中移动到同步队列当中，等待获取锁
868	*/
869	final boolean transferForSignal(Node node) {
870	/*
871	* 修改节点信号量状态为0，失败直接返回false
872	*/
873	if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
874	return false;
875
876	/*
877	* 加入同步队列尾部当中，返回前驱节点
878	*/
879Node p = enq(node);
880int ws = p.waitStatus;
881//前驱节点不可用 或者 修改信号量状态失败
882if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
883LockSupport.unpark(node.thread); //唤醒当前节点
884return true;
885	}
886
887	final boolean transferAfterCancelledWait(Node node) {
888	if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
889	enq(node);
890	return true;
891	}
892	/*
893	* If we lost out to a signal(), then we can't proceed
894	* until it finishes its enq(). Cancelling during an
895	* incomplete transfer is both rare and transient, so just
896	* spin.
897	*/
898	while (!isOnSyncQueue(node))
899	Thread.yield();
900	return false;

901	}
902
903	/**
904	* 入参就是新创建的节点，即当前节点
905	*/
906final int fullyRelease(Node node) {
907boolean failed = true;
908try {
909//这里这个取值要注意，获取当前的state并释放，这从另一个角度说明必须是独占锁
910//可以考虑下这个逻辑放在共享锁下面会发生什么？
911int savedState = getState(); 912	if (release(savedState)) { 913	failed = false;
914	return savedState;
915	} else {
916	//如果这里释放失败，则抛出异常
917	throw new IllegalMonitorStateException();
918	}
919	} finally {
920	/**
921	* 如果释放锁失败，则把节点取消，由这里就能看出来上面添加节点的逻辑中
922	* 只需要判断最后一个节点是否被取消就可以了
923	*/
924	if (failed)
925	node.waitStatus = Node.CANCELLED;
926	}
927	}
928
929	// Instrumentation methods for conditions
930
931	public final boolean hasWaiters(ConditionObject condition) {
932	if (!owns(condition))
933	throw new IllegalArgumentException("Not owner");
934	return condition.hasWaiters();

935	}
936
937	/**
938	* 获取条件队列长度
939	*/
940	public final int getWaitQueueLength(ConditionObject condition
{
941	if (!owns(condition))
942	throw new IllegalArgumentException("Not owner");
943	return condition.getWaitQueueLength();
944	}
945
946	/**
947	* 获取条件队列当中所有等待的thread集合
948	*/
949	public final Collection<Thread> getWaitingThreads(ConditionOb ect condition) {
950	if (!owns(condition))
951	throw new IllegalArgumentException("Not owner");
952	return condition.getWaitingThreads();
953	}
954
955	/**
956	* 条件对象，实现基于条件的具体行为
957	*/
958	public class ConditionObject implements Condition, java.io.Se ializable {
959	private static final long serialVersionUID = 1173984872572414 99L;
960	/** First node of condition queue. */ 961	private transient Node firstWaiter; 962	/** Last node of condition queue. */ 963	private transient Node lastWaiter; 964
965	/**
966	* Creates a new {@code ConditionObject} instance.

967	*/
968	public ConditionObject() { }
969
970	// Internal methods
971
972	/**
973	* 1.与同步队列不同，条件队列头尾指针是firstWaiter跟lastWaiter
974	* 2.条件队列是在获取锁之后，也就是临界区进行操作，因此很多地方不用考虑并发
975	*/
976private Node addConditionWaiter() {
977Node t = lastWaiter;
978//如果最后一个节点被取消，则删除队列中被取消的节点
979//至于为啥是最后一个节点后面会分析
980if (t != null && t.waitStatus != Node.CONDITION) {
981//删除所有被取消的节点
982unlinkCancelledWaiters();
983t = lastWaiter;
984	}
985//创建一个类型为CONDITION的节点并加入队列，由于在临界区，所以这里不用并发控制
986Node node = new Node(Thread.currentThread(), Node.CONDITION);
987if (t == null)
988firstWaiter = node;
989else
990t.nextWaiter = node; 991	lastWaiter = node; 992	return node;
993	}
994
995	/**
996	* 发信号，通知遍历条件队列当中的节点转移到同步队列当中，准备排队获取锁
997	*/
998	private void doSignal(Node first) {
999	do {

1000	if ( (firstWaiter = first.nextWaiter) == null)
1001	lastWaiter = null;
1002	first.nextWaiter = null;
1003	} while (!transferForSignal(first) && //转移节点
1004	(first = firstWaiter) != null);
1005	}
1006
1007	/**
1008	* 通知所有节点移动到同步队列当中，并将节点从条件队列删除
1009	*/
1010	private void doSignalAll(Node first) {
1011	lastWaiter = firstWaiter = null;
1012	do {
1013	Node next = first.nextWaiter;
1014	first.nextWaiter = null; 1015	transferForSignal(first); 1016	first = next;
1017	} while (first != null);
1018	}
1019
1020	/**
1021	* 删除条件队列当中被取消的节点
1022	*/
1023	private void unlinkCancelledWaiters() {
1024	Node t = firstWaiter; 1025	Node trail = null; 1026	while (t != null) {
1027	Node next = t.nextWaiter;
1028	if (t.waitStatus != Node.CONDITION) {
1029	t.nextWaiter = null; 1030	if (trail == null) 1031	firstWaiter = next; 1032	else
1033	trail.nextWaiter = next;
1034	if (next == null)

1035	lastWaiter = trail;
1036	}
1037	else
1038	trail = t; 1039	t = next; 1040	}
1041	}
1042
1043	// public methods
1044
1045	/**
1046	* 发新号，通知条件队列当中节点到同步队列当中去排队
1047	*/
1048	public final void signal() {
1049	if (!isHeldExclusively())//节点不能已经持有独占锁
1050	throw new IllegalMonitorStateException();
1051	Node first = firstWaiter;
1052	if (first != null)
1053	/**
1054	* 发信号通知条件队列的节点准备到同步队列当中去排队
1055	*/
1056	doSignal(first);
1057	}
1058
1059	/**
1060	* 唤醒所有条件队列的节点转移到同步队列当中
1061	*/
1062	public final void signalAll() {
1063	if (!isHeldExclusively())
1064	throw new IllegalMonitorStateException();
1065	Node first = firstWaiter;
1066	if (first != null)
1067	doSignalAll(first);
1068	}
1069

1070	/**
1071	* Implements uninterruptible condition wait.
1072	* <ol>
1073	* <li> Save lock state returned by {@link #getState}.
1074	* <li> Invoke {@link #release} with saved state as argument,
1075	* throwing IllegalMonitorStateException if it fails.
1076	* <li> Block until signalled.
1077	* <li> Reacquire by invoking specialized version of
1078	* {@link #acquire} with saved state as argument.
1079	* </ol>
1080	*/
1081	public final void awaitUninterruptibly() {
1082	Node node = addConditionWaiter(); 1083	int savedState = fullyRelease(node); 1084	boolean interrupted = false;
1085	while (!isOnSyncQueue(node)) {
1086	LockSupport.park(this);
1087	if (Thread.interrupted())
1088	interrupted = true;
1089	}
1090	if (acquireQueued(node, savedState) || interrupted)
1091	selfInterrupt();
1092	}
1093
1094	/** 该模式表示在退出等待时重新中断 */
1095	private static final int REINTERRUPT = 1;
1096	/** 异常中断 */
1097	private static final int THROW_IE = ‐1;
1098
1099	/**
1100	* 这里的判断逻辑是：
1101	* 1.如果现在不是中断的，即正常被signal唤醒则返回0
1102	* 2.如果节点由中断加入同步队列则返回THROW_IE，由signal加入同步队列则返回REINTERRUPT
1103	*/

1104	private int checkInterruptWhileWaiting(Node node) {
1105	return Thread.interrupted() ?
1106	(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
1107	0;
1108	}
1109
1110	/**
1111	* 根据中断时机选择抛出异常或者设置线程中断状态
1112	*/
1113	private void reportInterruptAfterWait(int interruptMode)
1114	throws InterruptedException {
1115	if (interruptMode == THROW_IE)
1116	throw new InterruptedException();
1117	else if (interruptMode == REINTERRUPT)
1118	selfInterrupt();
1119	}
1120
1121	/**
1122	* 加入条件队列等待，条件队列入口
1123	*/
1124	public final void await() throws InterruptedException {
1125
1126	//T2进来
1127	//如果当前线程被中断则直接抛出异常
1128	if (Thread.interrupted())
1129	throw new InterruptedException();
1130	//把当前节点加入条件队列
1131	Node node = addConditionWaiter();
1132	//释放掉已经获取的独占锁资源
1133	int savedState = fullyRelease(node);//T2释放锁
1134	int interruptMode = 0;
1135	//如果不在同步队列中则不断挂起
1136	while (!isOnSyncQueue(node)) {
1137	LockSupport.park(this);//T1被阻塞
1138	//这里被唤醒可能是正常的signal操作也可能是中断

1139	if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
1140	break;
1141	}
1142	/**
1143	* 走到这里说明节点已经条件满足被加入到了同步队列中或者中断了
1144	* 这个方法很熟悉吧？就跟独占锁调用同样的获取锁方法，从这里可以看出条件队列只能用于独占锁
1145	* 在处理中断之前首先要做的是从同步队列中成功获取锁资源
1146	*/
1147	if (acquireQueued(node, savedState) && interruptMode != THROW
_IE)
1148	interruptMode = REINTERRUPT;
1149	//走到这里说明已经成功获取到了独占锁，接下来就做些收尾工作
1150	//删除条件队列中被取消的节点
1151	if (node.nextWaiter != null) // clean up if cancelled
1152	unlinkCancelledWaiters();
1153	//根据不同模式处理中断
1154	if (interruptMode != 0)
1155	reportInterruptAfterWait(interruptMode);
1156	}
1157

1158
1159	/**
1160	* Implements timed condition wait.
1161	* <ol>
1162	* <li> If current thread is interrupted, throw InterruptedExc eption.
1163	* <li> Save lock state returned by {@link #getState}.
1164	* <li> Invoke {@link #release} with saved state as argument,
1165	* throwing IllegalMonitorStateException if it fails.
1166	* <li> Block until signalled, interrupted, or timed out.
1167	* <li> Reacquire by invoking specialized version of
1168	* {@link #acquire} with saved state as argument.
1169	* <li> If interrupted while blocked in step 4, throw Interrup tedException.

1170	* <li> If timed out while blocked in step 4, return false, el se true.
1171	* </ol>
1172	*/
1173	public final boolean await(long time, TimeUnit unit)
1174	throws InterruptedException {
1175	long nanosTimeout = unit.toNanos(time);
1176	if (Thread.interrupted())
1177	throw new InterruptedException(); 1178	Node node = addConditionWaiter(); 1179	int savedState = fullyRelease(node);
1180	final long deadline = System.nanoTime() + nanosTimeout;
1181	boolean timedout = false;
1182	int interruptMode = 0;
1183	while (!isOnSyncQueue(node)) {
1184	if (nanosTimeout <= 0L) {
1185	timedout = transferAfterCancelledWait(node);
1186	break;
1187	}
1188	if (nanosTimeout >= spinForTimeoutThreshold)
1189	LockSupport.parkNanos(this, nanosTimeout);
1190	if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
1191	break;
1192	nanosTimeout = deadline ‐ System.nanoTime();
1193	}
1194	if (acquireQueued(node, savedState) && interruptMode != THROW
_IE)
1195 interruptMode = REINTERRUPT; 1196 if (node.nextWaiter != null) 1197 unlinkCancelledWaiters();
1198 if (interruptMode != 0)
1199	reportInterruptAfterWait(interruptMode);
1200	return !timedout;
1201	}
1202

1203

1204	final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
1205	return sync == AbstractQueuedSynchronizer.this;
1206	}
1207
1208	/**
1209	* Queries whether any threads are waiting on this condition.
1210	* Implements {@link AbstractQueuedSynchronizer#hasWaiters(Con ditionObject)}.
1211	*
1212	* @return {@code true} if there are any waiting threads
1213	* @throws IllegalMonitorStateException if {@link #isHeldExclu sively}
1214	* returns {@code false}
1215	*/
1216	protected final boolean hasWaiters() {
1217	if (!isHeldExclusively())
1218	throw new IllegalMonitorStateException();
1219	for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
1220	if (w.waitStatus == Node.CONDITION)
1221	return true;
1222	}
1223	return false;
1224	}
1225
1226	/**
1227	* Returns an estimate of the number of threads waiting on
1228	* this condition.
1229	* Implements {@link AbstractQueuedSynchronizer#getWaitQueueLe ngth(ConditionObject)}.
1230	*
1231	* @return the estimated number of waiting threads
1232	* @throws IllegalMonitorStateException if {@link #isHeldExclu sively}
1233	* returns {@code false}
1234	*/
1235	protected final int getWaitQueueLength() {

1236	if (!isHeldExclusively())
1237	throw new IllegalMonitorStateException();
1238	int n = 0;
1239	for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
1240	if (w.waitStatus == Node.CONDITION)
1241	++n;
1242	}
1243	return n;
1244	}
1245
1246	/**
1247	* 得到同步队列当中所有在等待的Thread集合
1248	*/
1249	protected final Collection<Thread> getWaitingThreads() {
1250	if (!isHeldExclusively())
1251	throw new IllegalMonitorStateException();
1252	ArrayList<Thread> list = new ArrayList<Thread>();
1253	for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
1254	if (w.waitStatus == Node.CONDITION) {
1255	Thread t = w.thread;
1256	if (t != null)
1257	list.add(t);
1258	}
1259	}
1260	return list;
1261	}
1262	}
1263
1264	/**
1265	* Setup to support compareAndSet. We need to natively impleme nt
1266	* this here: For the sake of permitting future enhancements, we
1267	* cannot explicitly subclass AtomicInteger, which would be
1268	* efficient and useful otherwise. So, as the lesser of evils, we

1269	* natively implement using hotspot intrinsics API. And while we
1270	* are at it, we do the same for other CASable fields (which c ould
1271	* otherwise be done with atomic field updaters).
1272	* unsafe魔法类，直接绕过虚拟机内存管理机制，修改内存
1273	*/
1274	private static final Unsafe unsafe = Unsafe.getUnsafe();
1275	//偏移量
1276	private static final long stateOffset; 1277	private static final long headOffset; 1278	private static final long tailOffset;
1279	private static final long waitStatusOffset;
1280	private static final long nextOffset;
1281
1282	static {
1283	try {
1284	//状态偏移量
1285	stateOffset = unsafe.objectFieldOffset
1286	(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
1287	//head指针偏移量，head指向CLH队列的头部
1288	headOffset = unsafe.objectFieldOffset
1289	(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
1290	tailOffset = unsafe.objectFieldOffset
1291	(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
1292	waitStatusOffset = unsafe.objectFieldOffset 1293	(Node.class.getDeclaredField("waitStatus")); 1294	nextOffset = unsafe.objectFieldOffset
1295	(Node.class.getDeclaredField("next"));
1296
1297	} catch (Exception ex) { throw new Error(ex); }
1298	}
1299
1300	/**
1301	* CAS 修改头部节点指向. 并发入队时使用.
1302	*/

1303	private final boolean compareAndSetHead(Node update) {
1304	return unsafe.compareAndSwapObject(this, headOffset, null, up date);
1305	}
1306
1307	/**
1308	* CAS 修改尾部节点指向. 并发入队时使用.
1309	*/
1310	private final boolean compareAndSetTail(Node expect, Node upd ate) {
1311	return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
1312	}
1313
1314	/**
1315	* CAS 修改信号量状态.
1316	*/
1317	private static final boolean compareAndSetWaitStatus(Node nod e,
1318	int expect,
1319	int update) {
1320	return unsafe.compareAndSwapInt(node, waitStatusOffset,
1321	expect, update);
1322	}
1323
1324	/**
1325	* 修改节点的后继指针.
1326	*/
1327	private static final boolean compareAndSetNext(Node node,
1328	Node expect,
1329	Node update) {
1330	return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
1331	}
1332 }
1333

1334
1335 AQS框架具体实现‐独占锁实现ReentrantLock
1336
1337 public class ReentrantLock implements Lock, java.io.Serializab le {
1338	private static final long serialVersionUID = 7373984872572414 699L;
1339	/**
1340	* 内部调用AQS的动作，都基于该成员属性实现
1341	*/
1342	private final Sync sync;
1343
1344	/**
1345	* ReentrantLock锁同步操作的基础类,继承自AQS框架.
1346	* 该类有两个继承类，1、NonfairSync 非公平锁，2、FairSync公平锁
1347	*/
1348	abstract static class Sync extends AbstractQueuedSynchronizer
{
1349	private static final long serialVersionUID = ‐517952376203402 5860L;
1350
1351	/**
1352	* 加锁的具体行为由子类实现
1353	*/
1354	abstract void lock();
1355
1356	/**
1357	* 尝试获取非公平锁
1358	*/
1359	final boolean nonfairTryAcquire(int acquires) {
1360	//acquires = 1
1361	final Thread current = Thread.currentThread();
1362	int c = getState();
1363	/**
1364	* 不需要判断同步队列（CLH）中是否有排队等待线程
1365	* 判断state状态是否为0，不为0可以加锁

1366	*/
1367	if (c == 0) {
1368	//unsafe操作，cas修改state状态
1369	if (compareAndSetState(0, acquires)) {
1370	//独占状态锁持有者指向当前线程
1371	setExclusiveOwnerThread(current);
1372	return true;
1373	}
1374	}
1375	/**
1376	* state状态不为0，判断锁持有者是否是当前线程，
1377	* 如果是当前线程持有 则state+1
1378	*/
1379	else if (current == getExclusiveOwnerThread()) {
1380	int nextc = c + acquires;
1381	if (nextc < 0) // overflow
1382	throw new Error("Maximum lock count exceeded");
1383	setState(nextc);
1384	return true;
1385	}
1386	//加锁失败
1387	return false;
1388	}
1389
1390	/**
1391	* 释放锁
1392	*/
1393	protected final boolean tryRelease(int releases) {
1394	int c = getState() ‐ releases;
1395	if (Thread.currentThread() != getExclusiveOwnerThread())
1396	throw new IllegalMonitorStateException();
1397	boolean free = false;
1398	if (c == 0) {
1399	free = true;
1400	setExclusiveOwnerThread(null);

1401	}
1402	setState(c);
1403	return free;
1404	}
1405
1406	/**
1407	* 判断持有独占锁的线程是否是当前线程
1408	*/
1409	protected final boolean isHeldExclusively() {
1410	return getExclusiveOwnerThread() == Thread.currentThread();
1411	}
1412
1413	//返回条件对象
1414	final ConditionObject newCondition() {
1415	return new ConditionObject();
1416	}
1417

1418
1419	final Thread getOwner() {
1420	return getState() == 0 ? null : getExclusiveOwnerThread();
1421	}
1422
1423	final int getHoldCount() {
1424	return isHeldExclusively() ? getState() : 0;
1425	}
1426
1427	final boolean isLocked() {
1428	return getState() != 0;
1429	}
1430
1431	/**
1432	* Reconstitutes the instance from a stream (that is, deserial izes it).
1433	*/
1434	private void readObject(java.io.ObjectInputStream s)

1435	throws java.io.IOException, ClassNotFoundException {
1436	s.defaultReadObject();
1437	setState(0); // reset to unlocked state
1438	}
1439	}
1440
1441	/**
1442	* 非公平锁
1443	*/
1444	static final class NonfairSync extends Sync {
1445	private static final long serialVersionUID = 7316153563782823 691L;
1446	/**
1447	* 加锁行为
1448	*/
1449	final void lock() {
1450	/**
1451	* 第一步：直接尝试加锁
1452	* 与公平锁实现的加锁行为一个最大的区别在于，此处不会去判断同步队列
(CLH队列)中
1453	* 是否有排队等待加锁的节点，上来直接加锁（判断state是否为0,CAS修改
state为1）
1454	* ，并将独占锁持有者 exclusiveOwnerThread 属性指向当前线程
1455	* 如果当前有人占用锁，再尝试去加一次锁
1456	*/
1457	if (compareAndSetState(0, 1))
1458	setExclusiveOwnerThread(Thread.currentThread());
1459	else
1460	//AQS定义的方法,加锁
1461	acquire(1);
1462	}
1463
1464	/**
1465	* 父类AbstractQueuedSynchronizer.acquire()中调用本方法
1466	*/
1467	protected final boolean tryAcquire(int acquires) {

1468	return nonfairTryAcquire(acquires);
1469	}
1470	}
1471
1472	/**
1473	* 公平锁
1474	*/
1475	static final class FairSync extends Sync {
1476	private static final long serialVersionUID = ‐300089789709046 6540L;
1477	final void lock() {
1478	acquire(1);
1479	}
1480	/**
1481	* 重写aqs中的方法逻辑
1482	* 尝试加锁，被AQS的acquire()方法调用
1483	*/
1484	protected final boolean tryAcquire(int acquires) {
1485	final Thread current = Thread.currentThread();
1486	int c = getState();
1487	if (c == 0) {
1488	/**
1489	* 与非公平锁中的区别，需要先判断队列当中是否有等待的节点
1490	* 如果没有则可以尝试CAS获取锁
1491	*/
1492	if (!hasQueuedPredecessors() && 1493	compareAndSetState(0, acquires)) { 1494	//独占线程指向当前线程
1495	setExclusiveOwnerThread(current);
1496	return true;
1497	}
1498	}
1499	else if (current == getExclusiveOwnerThread()) {
1500	int nextc = c + acquires;
1501	if (nextc < 0)

1502	throw new Error("Maximum lock count exceeded");
1503	setState(nextc);
1504	return true;
1505	}
1506	return false;
1507	}
1508	}
1509
1510	/**
1511	* 默认构造函数，创建非公平锁对象
1512	*/
1513	public ReentrantLock() { 1514	sync = new NonfairSync(); 1515	}
1516
1517	/**
1518	* 根据要求创建公平锁或非公平锁
1519	*/
1520	public ReentrantLock(boolean fair) {
1521	sync = fair ? new FairSync() : new NonfairSync();
1522	}
1523
1524	/**
1525	* 加锁
1526	*/
1527	public void lock() {
1528	sync.lock();
1529	}
1530
1531	/**
1532	* 尝试获去取锁，获取失败被阻塞，线程被中断直接抛出异常
1533	*/
1534	public void lockInterruptibly() throws InterruptedException {
1535	sync.acquireInterruptibly(1);
1536	}

1537
1538	/**
1539	* 尝试加锁
1540	*/
1541	public boolean tryLock() {
1542	return sync.nonfairTryAcquire(1);
1543	}
1544
1545	/**
1546	* 指定等待时间内尝试加锁
1547	*/
1548	public boolean tryLock(long timeout, TimeUnit unit)
1549	throws InterruptedException {
1550	return sync.tryAcquireNanos(1, unit.toNanos(timeout));
1551	}
1552
1553	/**
1554	* 尝试去释放锁
1555	*/
1556	public void unlock() {
1557	sync.release(1);
1558	}
1559
1560	/**
1561	* 返回条件对象
1562	*/
1563	public Condition newCondition() {
1564	return sync.newCondition();
1565	}
1566
1567	/**
1568	* 返回当前线程持有的state状态数量
1569	*/
1570	public int getHoldCount() {
1571	return sync.getHoldCount();

1572	}
1573
1574	/**
1575	* 查询当前线程是否持有锁
1576	*/
1577	public boolean isHeldByCurrentThread() {
1578	return sync.isHeldExclusively();
1579	}
1580
1581	/**
1582	* 状态表示是否被Thread加锁持有
1583	*/
1584	public boolean isLocked() {
1585	return sync.isLocked();
1586	}
1587
1588	/**
1589	* 是否公平锁？是返回true 否则返回 false
1590	*/
1591	public final boolean isFair() { 1592	return sync instanceof FairSync; 1593	}
1594
1595	/**
1596	* 获取持有锁的当前线程
1597	*/
1598	protected Thread getOwner() {
1599	return sync.getOwner();
1600	}
1601
1602	/**
1603	* 判断队列当中是否有在等待获取锁的Thread节点
1604	*/
1605	public final boolean hasQueuedThreads() {
1606	return sync.hasQueuedThreads();

1607	}
1608
1609	/**
1610	* 当前线程是否在同步队列中等待
1611	*/
1612	public final boolean hasQueuedThread(Thread thread) {
1613	return sync.isQueued(thread);
1614	}
1615
1616	/**
1617	* 获取同步队列长度
1618	*/
1619	public final int getQueueLength() {
1620	return sync.getQueueLength();
1621	}
1622
1623	/**
1624	* 返回Thread集合，排队中的所有节点Thread会被返回
1625	*/
1626	protected Collection<Thread> getQueuedThreads() {
1627	return sync.getQueuedThreads();
1628	}
1629
1630	/**
1631	* 条件队列当中是否有正在等待的节点
1632	*/
1633	public boolean hasWaiters(Condition condition) {
1634	if (condition == null)
1635	throw new NullPointerException();
1636	if (!(condition instanceof AbstractQueuedSynchronizer.Conditi onObject))
1637	throw new IllegalArgumentException("not owner");
1638	return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionO bject)condition);
1639	}
1640