重入锁

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;//前一个结点的
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

 1 protected final boolean tryRelease(int releases) { 
 2 　　int c = getState() - releases; //计算出state的新值
 3 　　if (Thread.currentThread() != getExclusiveOwnerThread())//判断当前线程是否为持锁的线程
 4 　　　　throw new IllegalMonitorStateException(); //如果不是，就抛异常
 5 　　boolean free = false; 
 6 　　if (c == 0) { //当state的值为0，说明当前在无线程占用锁，即锁可以被释放掉
 7 　　　　free = true; //修改free值
 8 　　　　setExclusiveOwnerThread(null); 
 9 　　}
10 　　setState(c); //更新state值
11 　　return free; //返回true表示锁被释放，返回false表示还有线程占用着锁
12 }

 1 protected final boolean tryAcquire(int acquires) { //公平获取
 2 　　final Thread current = Thread.currentThread(); //获取当前线程
 3 　　int c = getState(); //计算新的state值
 4 　　if (c == 0) { //当前锁是空闲状态
 5 　　　　　　if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { 
 6 　　　　　　　　　　setExclusiveOwnerThread(current);
 7 　　　　　　　　　　return true; 
 8 　　　　　　} 
 9 　　} else if (current == getExclusiveOwnerThread()) { //当前线程是持有锁的线程
10 　　　　　　int nextc = c + acquires; 
11 　　　　　　if (nextc < 0) throw new Error("Maximum lock count exceeded"); 
12 　　　　　　setState(nextc); 
13 　　　　　　return true; 
14 　　}
15 　　return false; 
16 }

 1 import java.util.concurrent.locks.Lock;
 2 import java.util.concurrent.locks.ReentrantLock;
 3 class ThreadDome implements Runnable{
 4     String name;
 5     public ThreadDome(String name){
 6         this.name=name;
 7     }
 8     Lock lock=new ReentrantLock(true);//公平性
 9     @Override
10     public void run() {
11         for (int i = 0; i <2; i++){
12             lock.lock();
13             try{
14                 Thread.sleep(1000);
15                 System.out.println(this.name);
16             }catch (Exception e){
17                 e.getMessage();
18             }finally {
19                 lock.unlock();
20             }
21         }
22     }
23 }
24 public class ReentrantLockTest {
25     public static void main(String[] args) {
26         for (int i = 0; i <5; i++) {
27             new Thread(new ThreadDome(""+i)).start();
28         }
29     }
30 }

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

 public final void acquireInterruptibly(int arg)throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }