【ReentrantLock】

傷城~ 2023-03-06 03:58 17阅读 0赞

### ReentrantLock ###

*   *   *   *   *  \[1\] ReentrantLock简介
                 *  \[2\] ReentrantLock方法
                 *  \[3\] ReentrantLock实战
                 *  \[4\] ReentrantLock原理
                 *  \[11\] ReentrantLock如何实现可重入锁？
                 *  \[12\] ReentrantLock如何实现公平锁和非公平锁？
                 *  \[8\] 条件变量Condition实现原理？
                 *  \[11\] 谈谈 synchronized 和 ReenTrantLock 的区别？

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

ReentrantLock ，re: 可重新 entrant：进入 Lock：锁 ，所以他就是可冲入锁

##### \[1\] ReentrantLock简介 #####

ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。相对于 synchronized 它具备如下特点：

*  **可重入（）**：是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住
 *  **可中断**：如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断
 *  **可以设置超时时间**
 *  **可以设置为公平锁**
 *  **支持多个条件变量**：synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的。

public class LockExample { 
    
        private Lock lock = new ReentrantLock();
    
        public void func() { 
            lock.lock();
            try { 
                for (int i = 0; i < 10; i++) { 
                    System.out.print(i + " ");
                }
            } finally { 
                lock.unlock(); // 确保释放锁，从而避免发生死锁。
            }
        }
    }

##### \[2\] ReentrantLock方法 #####

*  **加锁**
    
    ReentrantLock 类提供了最基本的加锁和解锁方法：
    
        public void lock();
    
        class Counter { 
            private static int counter = 0;
            private static ReentrantLock lock = new ReentrantLock();
        
            public static int getCounter() { 
                return counter;
            }
        
            public static void increase() { 
                try { 
                    lock.lock();
                    counter++;
                } finally { 
                    lock.unlock();
                }
            }
        
            private Counter() { };
        }
    
    这个方法保证了线程安全，他和 synchronized 关键字实现了相同的效果：
    
        class Counter { 
            private static int counter = 0;
        
            public static int getCounter() { 
                return counter;
            }
        
            public synchronized static void increase() { 
                counter++;
            }
        
            private Counter() { };
        }
    
    显然，synchronized 关键字的实现更为简洁和清晰，同时，如果 ReentrantLock 忘记调用 unlock 方法将会造成死锁，这是必须要注意的一点
    
    因此，如果仅仅是想要进行上面代码中这样的加锁和解锁，synchronized 还是最好的选择
 *  **可重入**
    
    默认可重入
 *  **可中断**
    
        public void lockInterruptibly()	// 可中断锁，调用线程 interrupt 方法，则锁方法抛出 InterruptedException
 *  **可以设置超时时间**
    
        public boolean tryLock(long timeout, TimeUnit unit)	// 尝试获取锁，最多等待 timeout 时长
 *  **可以设置为公平锁**：
    
    使用 synchronized 锁是不保证等待的线程获取到锁的顺序的，这就是非公平锁，除了默认的非公平锁构造方法外，ReentrantLock 还提供了一个带有 boolean 参数的构造方法：
    
        public ReentrantLock(boolean fair);
    
    如果传入参数为 true，则会创建公平锁，所谓的公平锁，就是保证了先进入等待的线程一定先获取到锁
    
    可以通过 isFair 方法查询 ReentrantLock 对象是否是公平锁：
    
        public final boolean isFair();
 *  **支持多个条件变量**

通过 newCondition 方法，可以创建出 Condition 对象

Condition 接口提供了如下的方法：

void await();								// 可被中断的等待
    boolean await(long time, TimeUnit unit);	// 最多等待 time 时长的可中断等待
    long awaitNanos(long nanosTimeout);			// 最多等待 nanosTimeout 毫秒的可中断等待
    boolean awaitUntil(Date deadline);			// 等待直到指定时间的可中断等待
    void awaitUninterruptibly();				// 不可中断的等待
    void signal();								// 唤醒一个线程
    void signalAll();							// 唤醒所有等待中的线程

上面的五个等待方法中，除了 awaitUninterruptibly 方法，其他四个都可以被 interrupt 方法中断，而 signal 和 signalAll 方法可以中断上述所有等待方法

但是，signal 和 signalAll 方法只能唤醒通过当前 Condition 对象调用过等待方法的线程

基于上述特性，我们可以精准的控制让某个指定的线程被唤醒，而 Object 的 notify、notifyAll 方法的唤醒则是随机的，同一个 ReentrantLock 每次调用 newCondition 方法都将获得不同的 Condition 对象

*  **查询接口**

int getHoldCount();		// 获取当前线程持有该锁的次数
    boolean isHeldByCurrentThread();	// 判断当前线程是否持有该锁
    boolean isLocked();		// 获取锁状态是否为加锁状态
    boolean isFair();		// 当前锁是否是公平锁
    Thread getOwner();		// 获取持有锁的线程
    boolean hasQueuedThreads();			// 判断当前锁是否有线程在等待
    boolean hasQueuedThread(Thread thread);	// 判断指定线程是否在等待该锁
    int getQueueLength();	// 获取正在等待该锁的线程数量
    boolean hasWaiters(Condition condition);	// 判断是否有线程等待在该 Condition 对象上
    int getWaitQueueLength(Condition condition);	// 获取等待在该 Condition 对象的线程数

##### \[3\] ReentrantLock实战 #####

**加锁及其解锁：**

class Counter { 
        private static int counter = 0;
        private static ReentrantLock lock = new ReentrantLock();
    public static int getCounter() { 
        return counter;
    }
    
    public static void increase() { 
        try { 
            lock.lock();
            counter++;
        } finally { 
            lock.unlock();
        }
    }
    
    private Counter() { };
        }

https://baijiahao.baidu.com/s?id=1648624077736116382&wfr=spider&for=pc

**可重入**：可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁

如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) { 
     method1();
    }
    public static void method1() { 
     lock.lock();
     try { 
     log.debug("execute method1");
     method2();
     } finally { 
     lock.unlock();
     }
    }
    public static void method2() { 
     lock.lock();
     try { 
     log.debug("execute method2");
     method3();
     } finally { 
     lock.unlock();
     }
    }
    public static void method3() { 
     lock.lock();
     try { 
     log.debug("execute method3");
     } finally { 
     lock.unlock();
     }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iTL7SlZk-1596597261052)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716080920156.png)\]

**可打断**：

ReentrantLock lock = new ReentrantLock();
    Thread t1 = new Thread(() -> { 
    北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
     log.debug("启动...");
     try { 
     lock.lockInterruptibly();
     } catch (InterruptedException e) { 
     e.printStackTrace();
     log.debug("等锁的过程中被打断");
     return;
     }
     try { 
     log.debug("获得了锁");
     } finally { 
     lock.unlock();
     }
    }, "t1");
    lock.lock();
    log.debug("获得了锁");
    t1.start();
    try { 
     sleep(1);
     t1.interrupt();
     log.debug("执行打断");
    } finally { 
     lock.unlock();
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MB1eTma4-1596597261054)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716080945053.png)\]

可超时：

ReentrantLock lock = new ReentrantLock();
    Thread t1 = new Thread(() -> { 
     log.debug("启动...");
     if (!lock.tryLock()) { 
     log.debug("获取立刻失败，返回");
     return;
     }
     try { 
     log.debug("获得了锁");
     } finally { 
     lock.unlock();
     }
    }, "t1");
    lock.lock();
    log.debug("获得了锁");
    t1.start();
    try { 
     sleep(2);
    } finally { 
     lock.unlock();
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1LMlhVC5-1596597261058)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716080851608.png)\]

**公平锁：**

ReentrantLock lock = new ReentrantLock(false);
    lock.lock();
    for (int i = 0; i < 500; i++) { 
     new Thread(() -> { 
     lock.lock();
     try { 
     System.out.println(Thread.currentThread().getName() + " running...");
     } finally { 
     lock.unlock();
     }
     }, "t" + i).start();
    }
    // 1s 之后去争抢锁
    Thread.sleep(1000);
    new Thread(() -> { 
     System.out.println(Thread.currentThread().getName() + " start...");
     lock.lock();
     try { 
     System.out.println(Thread.currentThread().getName() + " running...");
     } finally { 
     lock.unlock();
     }
    }, "强行插入").start();
    lock.unlock()

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JykONJsJ-1596597261061)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716080827688.png)\]

**条件变量**

synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待

ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

synchronized 是那些不满足条件的线程都在一间休息室等消息

**而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤**

**醒**

使用要点：

await 前需要获得锁

await 执行后，会释放锁，进入 conditionObject 等待

await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁

竞争 lock 锁成功后，从 await 后继续执行

static ReentrantLock lock = new ReentrantLock();
    static Condition waitCigaretteQueue = lock.newCondition();
    static Condition waitbreakfastQueue = lock.newCondition();
    static volatile boolean hasCigrette = false;
    static volatile boolean hasBreakfast = false;
    public static void main(String[] args) { 
     new Thread(() -> { 
     try { 
     lock.lock();
     while (!hasCigrette) { 
          try { 
     waitCigaretteQueue.await();
     } catch (InterruptedException e) { 
     e.printStackTrace();
     }
     }
     log.debug("等到了它的烟");
     } finally { 
     lock.unlock();
     }
     }).start();
     new Thread(() -> { 
     try { 
     lock.lock();
     while (!hasBreakfast) { 
     try { 
     waitbreakfastQueue.await();
     } catch (InterruptedException e) { 
     e.printStackTrace();
     }
     }
     log.debug("等到了它的早餐");
     } finally { 
     lock.unlock();
     }
     }).start();
     sleep(1);
     sendBreakfast();
     sleep(1);
     sendCigarette();
    }
    private static void sendCigarette() { 
     lock.lock();
     try { 
     log.debug("送烟来了");
     hasCigrette = true;
     waitCigaretteQueue.signal();
     } finally { 
     lock.unlock();
     }
    }
    private static void sendBreakfast() { 
     lock.lock();
     try { 
     log.debug("送早餐来了");
     hasBreakfast = true;
     waitbreakfastQueue.signal();
     } finally { 
     lock.unlock();
          }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uzVknEdX-1596597261062)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716080757372.png)\]

##### \[4\] ReentrantLock原理 #####

**如何实现一个锁?**

实现一个锁，主要需要考虑2个问题

1.  **如何线程安全的修改锁状态位？**
2.  **得不到锁的线程，如何排队？**

带着这2个问题，我们看一下JUC中的ReentrantLock是如何做的？

ReentrantLock类的大部分逻辑，都是其均继承自AQS的内部类Sync实现的

**如何线程安全的修改锁状态位？**

**锁状态位的修改主要通过，内部类Sync实现的，们可以发现线程安全的关键在于：volatile变量和CAS原语的配合使用**

public abstract class AbstractQueuedSynchronizer{ 
             //锁状态标志位：volatile变量（多线程间通过此变量判断锁的状态）
              private volatile int state;
             
              protected final int getState() { 
                     return state;
              }
    
     
             protected final void setState(int newState) { 
                  state = newState;
             }
    
        }
      
        abstract static  Sync extends AbstractQueuedSynchronizer { 
        
            
             final boolean nonfairTryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                //volatile读，确保了锁状态位的内存可见性
                int c = getState();
                //锁还没有被其他线程占用
                if (c == 0) { 
                    //此时，如果多个线程同时进入，CAS操作会确保，只有一个线程修改成功
                    if (compareAndSetState(0, acquires)) { 
                        //设置当前线程拥有独占访问权
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                //当前线程就是拥有独占访问权的线程，即锁重入
                else if (current == getExclusiveOwnerThread()) { 
                    //重入锁计数+1
                    int nextc = c + acquires;
                    if (nextc < 0) //溢出
                        throw new Error("Maximum lock count exceeded");
                    //只有获取锁的线程，才能进入此段代码，因此只需要一个volatile写操作，确保其内存可见性即可
                    setState(nextc);
                    return true;
                }
                return false;
            }
            
            //只有获取锁的线程才会执行此方法，因此只需要volatile读写确保内存可见性即可
            protected final boolean tryRelease(int releases) { 
                //锁计数器-1
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                //锁计数器为0，说明锁被释放
                if (c == 0) { 
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }
        }

**得不到锁的线程，如何排队？**

JUC中锁的排队策略，是基于CLH队列的变种实现的。因此，我们先看看啥是CLH队列

![img][]

如上图所示，**获取不到锁的线程，会进入队尾，然后自旋，直到其前驱线程释放锁。**

这样做的好处：假设有1000个线程等待获取锁，锁释放后，只会通知队列中的第一个线程去竞争锁，减少了并发冲突。（ZK的分布式锁，为了避免惊群效应，也使用了类似的方式：获取不到锁的线程只监听前一个节点）

为什么说JUC中的实现是基于CLH的“变种”，因为原始CLH队列，一般用于实现自旋锁。而JUC中的实现，获取不到锁的线程，一般会时而阻塞，时而唤醒。

##### \[11\] ReentrantLock如何实现可重入锁？ #####

可重入锁的实现原理：

**如果当前锁的状态不为0，表示有线程占有该锁。再判断如果当前线程就是占有这个锁的线程，修改当前线程的同步状态值，同步状态加1，这样就实现了可重入。**  
**每次重新获取都会对同步状态进行加一的操作，那么释放的时候处理思路是怎样的了？释放锁会调用unlock方法，内部有一个tryRelease方法，每释放一次锁同步状态减1，只有当同步状态为0时，锁成功被释放，返回true。**

static final class NonfairSync extends Sync { 
     // ...
     
     // Sync 继承过来的方法, 方便阅读, 放在此处
     final boolean nonfairTryAcquire(int acquires) { 
     final Thread current = Thread.currentThread();
     int c = getState();
     if (c == 0) { 
     if (compareAndSetState(0, acquires)) { 
     setExclusiveOwnerThread(current);
     return true;
     }
     }
     // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
     else if (current == getExclusiveOwnerThread()) { 
     // state++
     int nextc = c + acquires;
     if (nextc < 0) // overflow
     throw new Error("Maximum lock count exceeded");
     setState(nextc);
     return true;
     }
     return false;
     }
     
     // Sync 继承过来的方法, 方便阅读, 放在此处
     protected final boolean tryRelease(int releases) { 
     // state-- 
     int c = getState() - releases;
     if (Thread.currentThread() != getExclusiveOwnerThread())
     throw new IllegalMonitorStateException();
     boolean free = false;
     // 支持锁重入, 只有 state 减为 0, 才释放成功
     if (c == 0) { 
     free = true;
     setExclusiveOwnerThread(null);
     }
     setState(c);
     return free;
     }
    }

##### \[12\] ReentrantLock如何实现公平锁和非公平锁？ #####

总结：公平锁和非公平锁\*\*(默认)\*\*只有两处不同：

**非公平：**

1.  调用lock()方法时，首先去通过CAS尝试设置锁资源的state变量，如果设置成功，则设置当前持有锁资源的线程为当前请求线程
2.  调用tryAcquire方法时，首先获取当前锁资源的state变量，如果为0，则通过CAS去尝试设置state，如果设置成功，则设置当前持有锁资源的线程为当前请求线程

**以上两步都属于插队现象，可以提高系统吞吐量**

**公平：**  
1.调用lock()方法时，不进行CAS尝试  
2.调用tryAcuqire方法时，首先获取当前锁资源的state变量，如果为0，则**判断该节点是否是头节点可以去获取锁资源，如果可以才通过CAS去尝试设置state**

上面通过判断该线程是否是队列的头结点，从而保证公平性

public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

公平锁的 lock 方法：

static final class FairSync extends Sync {
        final void lock() {
            acquire(1);
        }
        // AbstractQueuedSynchronizer.acquire(int arg)
        public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 1. 和非公平锁相比，这里多了一个判断：是否有线程在等待
                if (!hasQueuedPredecessors() &&
                    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;
        }
    }

非公平锁的 lock 方法：

static final class NonfairSync extends Sync {
        final void lock() {
            // 2. 和公平锁相比，这里会直接先进行一次CAS，成功就返回了
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        // AbstractQueuedSynchronizer.acquire(int arg)
        public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    /**
     * Performs non-fair tryLock.  tryAcquire is implemented in
     * subclasses, but both need nonfair try for trylock method.
     */
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

##### \[8\] 条件变量Condition实现原理？ #####

**Condition的作用和Object.wait()和Object.notify()的作用相同，可以使当前线程阻塞和唤醒。只不过condition需要与reentrantlock配合使用，而wait/notify需要与snychronized配合使用。**

通过Lock接口（重入锁实现了这一接口）的new Condition()方法可以生成一个与当前重入锁绑定的Condition实例，**每个条件变量其实就对应着一个等待队列**，其实现类是 ConditionObject。

**condition常用的方法：**

*  await()方法会使当前线程等待，同时释放当前锁,当其他线程中使用signal()或signalAll()方法时，线程会重新获得锁并继续执行。或者当其他线程被中断时，也能跳出等待。这和Object.wait()很相似。
 *  awaitUninterruptibly()与await()方法基本相同，但他并不会在中断过程中响应中断。
 *  signal()方法用于唤醒一个在等待中的线程。相对的signalAll()方法会唤醒所有在等待中的线程。这和Object.notifyAll()很类似。

**await** **流程**：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jMm72yas-1596597261064)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716144925408.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMAEebzS-1596597261064)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716144941742.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DsZNOw6L-1596597261065)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716145003743.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rcrDaVJb-1596597261066)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716145017143.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EJOKM9xd-1596597261067)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716145225664.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ocxsu6I-1596597261067)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716145341008.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZEvW1OF-1596597261069)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200716145416997.png)\]

public class ConditionObject implements Condition, java.io.Serializable { 
     private static final long serialVersionUID = 1173984872572414699L;
     
     // 第一个等待节点
     private transient Node firstWaiter;
     
     // 最后一个等待节点
     private transient Node lastWaiter;
     public ConditionObject() {  }
     // ㈠ 添加一个 Node 至等待队列
     private Node addConditionWaiter() { 
     Node t = lastWaiter;
     // 所有已取消的 Node 从队列链表删除, 见 ㈡
     if (t != null && t.waitStatus != Node.CONDITION) { 
     unlinkCancelledWaiters();
     t = lastWaiter;
     }
     // 创建一个关联当前线程的新 Node, 添加至队列尾部
     Node node = new Node(Thread.currentThread(), Node.CONDITION);
     if (t == null)
     firstWaiter = node;
     else
     t.nextWaiter = node;
     lastWaiter = node;
     return node;
     }
     // 唤醒 - 将没取消的第一个节点转移至 AQS 队列
     private void doSignal(Node first) { 
     do { 
     // 已经是尾节点了
     if ( (firstWaiter = first.nextWaiter) == null) { 
     lastWaiter = null;
     }
     first.nextWaiter = null;
     } while (
     // 将等待队列中的 Node 转移至 AQS 队列, 不成功且还有节点则继续循环 ㈢
     !transferForSignal(first) &&
     // 队列还有节点
     (first = firstWaiter) != null
     );
     }
     
     // 外部类方法, 方便阅读, 放在此处
     // ㈢ 如果节点状态是取消, 返回 false 表示转移失败, 否则转移成功
     final boolean transferForSignal(Node node) { 
     // 如果状态已经不是 Node.CONDITION, 说明被取消了
     if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
     return false;
     // 加入 AQS 队列尾部
     Node p = enq(node);
     int ws = p.waitStatus;
     if (
     // 上一个节点被取消
     ws > 0 ||
     // 上一个节点不能设置状态为 Node.SIGNAL
     !compareAndSetWaitStatus(p, ws, Node.SIGNAL) 
     ) { 
     // unpark 取消阻塞, 让线程重新同步状态
     LockSupport.unpark(node.thread);
     }
     return true;
     }
     // 全部唤醒 - 等待队列的所有节点转移至 AQS 队列
    北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
     private void doSignalAll(Node first) { 
     lastWaiter = firstWaiter = null;
     do { 
     Node next = first.nextWaiter;
     first.nextWaiter = null;
     transferForSignal(first);
     first = next;
     } while (first != null);
     }
     
     // ㈡
     private void unlinkCancelledWaiters() { 
     // ...
     }
     // 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
     public final void signal() { 
     if (!isHeldExclusively())
     throw new IllegalMonitorStateException();
     Node first = firstWaiter;
     if (first != null)
     doSignal(first);
     }
     // 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
     public final void signalAll() { 
     if (!isHeldExclusively())
     throw new IllegalMonitorStateException();
     Node first = firstWaiter;
     if (first != null)
     doSignalAll(first);
     }
     // 不可打断等待 - 直到被唤醒
     public final void awaitUninterruptibly() { 
     // 添加一个 Node 至等待队列, 见 ㈠
     Node node = addConditionWaiter();
     // 释放节点持有的锁, 见 ㈣
     int savedState = fullyRelease(node);
     boolean interrupted = false;
     // 如果该节点还没有转移至 AQS 队列, 阻塞
     while (!isOnSyncQueue(node)) { 
     // park 阻塞
     LockSupport.park(this);
     // 如果被打断, 仅设置打断状态
     if (Thread.interrupted())
     interrupted = true;
     }
     // 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
     if (acquireQueued(node, savedState) || interrupted)
     selfInterrupt();
     }
     
    北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
     // 外部类方法, 方便阅读, 放在此处
     // ㈣ 因为某线程可能重入，需要将 state 全部释放
     final int fullyRelease(Node node) { 
     boolean failed = true;
     try { 
     int savedState = getState();
     if (release(savedState)) { 
     failed = false;
     return savedState;
     } else { 
     throw new IllegalMonitorStateException();
     }
     } finally { 
     if (failed)
     node.waitStatus = Node.CANCELLED;
     }
     }
     // 打断模式 - 在退出等待时重新设置打断状态
     private static final int REINTERRUPT = 1;
     // 打断模式 - 在退出等待时抛出异常
     private static final int THROW_IE = -1;
     // 判断打断模式
     private int checkInterruptWhileWaiting(Node node) { 
     return Thread.interrupted() ?
     (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
     0;
     }
     // ㈤ 应用打断模式
     private void reportInterruptAfterWait(int interruptMode)
     throws InterruptedException { 
     if (interruptMode == THROW_IE)
     throw new InterruptedException();
     else if (interruptMode == REINTERRUPT)
     selfInterrupt();
     }
     // 等待 - 直到被唤醒或打断
     public final void await() throws InterruptedException { 
     if (Thread.interrupted()) { 
     throw new InterruptedException();
     }
     // 添加一个 Node 至等待队列, 见 ㈠
     Node node = addConditionWaiter();
     // 释放节点持有的锁
     int savedState = fullyRelease(node);
     int interruptMode = 0;
     // 如果该节点还没有转移至 AQS 队列, 阻塞
     while (!isOnSyncQueue(node)) { 
     // park 阻塞
     LockSupport.park(this);
    北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
     // 如果被打断, 退出等待队列
     if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
     break;
     }
     // 退出等待队列后, 还需要获得 AQS 队列的锁
     if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
     interruptMode = REINTERRUPT;
     // 所有已取消的 Node 从队列链表删除, 见 ㈡
     if (node.nextWaiter != null) 
     unlinkCancelledWaiters();
     // 应用打断模式, 见 ㈤
     if (interruptMode != 0)
     reportInterruptAfterWait(interruptMode);
     }
     // 等待 - 直到被唤醒或打断或超时
     public final long awaitNanos(long nanosTimeout) throws InterruptedException { 
     if (Thread.interrupted()) { 
     throw new InterruptedException();
     }
     // 添加一个 Node 至等待队列, 见 ㈠
     Node node = addConditionWaiter();
     // 释放节点持有的锁
     int savedState = fullyRelease(node);
     // 获得最后期限
     final long deadline = System.nanoTime() + nanosTimeout;
     int interruptMode = 0;
     // 如果该节点还没有转移至 AQS 队列, 阻塞
     while (!isOnSyncQueue(node)) { 
     // 已超时, 退出等待队列
     if (nanosTimeout <= 0L) { 
     transferAfterCancelledWait(node);
     break;
     }
     // park 阻塞一定时间, spinForTimeoutThreshold 为 1000 ns
     if (nanosTimeout >= spinForTimeoutThreshold)
     LockSupport.parkNanos(this, nanosTimeout);
     // 如果被打断, 退出等待队列
     if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
     break;
     nanosTimeout = deadline - System.nanoTime();
     }
     // 退出等待队列后, 还需要获得 AQS 队列的锁
     if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
     interruptMode = REINTERRUPT;
     // 所有已取消的 Node 从队列链表删除, 见 ㈡
     if (node.nextWaiter != null)
     unlinkCancelledWaiters();
     // 应用打断模式, 见 ㈤
     if (interruptMode != 0)
     reportInterruptAfterWait(interruptMode);
     return deadline - System.nanoTime();
     }
     // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
     public final boolean awaitUntil(Date deadline) throws InterruptedException { 
     // ...
     }
     // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
     public final boolean await(long time, TimeUnit unit) throws InterruptedException { 
     // ...
     }
     // 工具方法 省略 ...
    }

##### \[11\] 谈谈 synchronized 和 ReenTrantLock 的区别？ #####

1.  **synchronized 是和 for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别**。既然 ReentrantLock 是类，那么它就提供了比 synchronized 更多更灵活的特性：**等待可中断、可实现公平锁、可实现选择性通知**（锁可以绑定多个条件）、性能已不是选择标准。
2.  **synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API。synchronized 是依赖于 JVM 实现的**，JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

> 1.  锁的实现：synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
> 2.  性能：新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
> 3.  等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。ReentrantLock 可中断，而 synchronized 不行。
> 4.  公平锁：公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
> 5.  锁绑定多个条件：一个 ReentrantLock 可以同时绑定多个 Condition 对象。

> **答：ReentrantLock是显示锁**，其提供了一些内部锁不具备的特性，但并不是内部锁的替代品。**显式锁支持公平和非公平的调度方式**，默认采用非公平调度。
> 
> **synchronized 内部锁简单，但是不灵活。显示锁支持在一个方法内申请锁，并且在另一个方法里释放锁。显示锁定义了一个tryLock（）方法，尝试去获取锁，成功返回true，失败并不会导致其执行的线程被暂停而是直接返回false，即可以**避免死锁\*\*。\*\*

[img]: /images/20230208/b7cc01a14a784b98b35fb45ba4ae8c1d.png