1.ReentrantLock.unlock()分析

(1)首先尝试释放锁，如果要求释放数等于锁状态数，那么将锁状态位清0，清除锁所有者，返回true；否则返回false;
(2)如果(1)返回的是true，说明锁完全释放。接下来将检查等待队列，并选择一个waitStatus处于等待状态的节点下的线程unpark(恢复)，选择的依据是从尾节点开始，选取最靠近头节点的等待节点,同时清理队列中线程被取消的节点；
(3)如果(1)返回false，说明锁只是部分释放，当前线程仍旧持有该锁；

 1java.util.concurrent.locks.ReentrantLock
 2 public void unlock() {
 3        sync.release(1);
 4 }
 5
 6java.util.concurrent.locks.AbstractQueuedSynchronizer
 7public final boolean release(int arg) {
 8        if (tryRelease(arg)) {   
 9            Node h = head;
10            if (h != null && h.waitStatus != 0)
11                unparkSuccessor(h);
12            return true;
13        }
14        return false;
15    }
16
17
18 protected final boolean tryRelease(int releases) {
19            int c = getState() - releases;   //重入锁加锁的次数-释放数量
20            if (Thread.currentThread() != getExclusiveOwnerThread())   //判断独占锁是否为当前线程所有
21                throw new IllegalMonitorStateException();
22            boolean free = false;
23            if (c == 0) {       //加锁次数=释放数量
24                free = true;
25                setExclusiveOwnerThread(null);     //清除锁拥有者标识
26            }
27            setState(c);        //设置加锁状态
28            return free;
29        }
30
31
32 /** *//**
33     * Wakes up node's successor, if one exists.
34     *
35     * @param node the node
36     */
37    private void unparkSuccessor(Node node) {
38        /**//*
39         * Try to clear status in anticipation of signalling.  It is
40         * OK if this fails or if status is changed by waiting thread.
41         */
42        compareAndSetWaitStatus(node, Node.SIGNAL, 0);    //清除头节点signal状态
43
44        /**//*
45         * Thread to unpark is held in successor, which is normally
46         * just the next node.  But if cancelled or apparently null,
47         * traverse backwards from tail to find the actual
48         * non-cancelled successor.
49         */
50        Node s = node.next;
51        if (s == null || s.waitStatus > 0) {    //等待队列唤醒的竞争满足FIFO，本段代码主要是寻找最靠近头节点的，且waitStatus为signal、condition的链表节点
52            s = null;
53            for (Node t = tail; t != null && t != node; t = t.prev)
54                if (t.waitStatus <= 0)
55                    s = t;
56        }
57        if (s != null)
58            LockSupport.unpark(s.thread);
59    }

package com.zxl.thread.notify;
/** *//**
 * 
 * @author zhangxl
 *
 */
public class SynThread1 extends Thread {
    
    private Object lockObj;
    private volatile int i = 0;
    public SynThread1(Object lockObj){
        this.lockObj = lockObj;
    }

    public void run(){
        
        synchronized(lockObj){
            while(true){
                if(i==0){
                    try {
                        System.out.println(Thread.currentThread().getName()+" will be waiting.");
                        lockObj.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                System.out.println(Thread.currentThread().getName()+": i="+i);
                //i++;
                
                if(i>=1) return;
            }
        }
    }
    
    public static void  main(String[] arg){
        
        Object lock = new Object();
        
        SynThread1 t1 = new SynThread1(lock);
        t1.setName("SynThread_1");
        SynThread1 t2 = new SynThread1(lock);
        t2.setName("SynThread_2");
        t2.start();
        t1.start();
        
        
        
        try {
            Thread.sleep(1000);
            
            synchronized(lock){
                lock.notify();    //通过结果观察，sun JVM(hotspot)的通知机制极有可能是FIFO的策略，原因是t1、t2只要谁先启动，谁就将被唤醒。
            }
        } catch (InterruptedException e) {
            // TODO Aut o-generated catch block            e.printStackTrace();
        }
    }
}

package com.zxl.thread.notify;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionThread implements Runnable {
 
 
 
 private ReentrantLock lock;
 
 private Condition c;
 
 private volatile int i=0;
 
 public ConditionThread(ReentrantLock lock){
  this.lock = lock;
  c = lock.newCondition();
 }

 public void run() {
  
  lock.lock();
  
  try{
   
   while(true){
    if(i==0){
     System.out.println(Thread.currentThread().getName()+" will be waiting...");
     c.await();
    }
    
    System.out.println(Thread.currentThread().getName()+" is already waked up,i="+i);
    
    if(i>=1) return;
   }
   
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally{
   lock.unlock();
  }
  
  
  
 }
 
 public Condition getCondition(){
  return c;
 }
 
 public static void main(String[] args){
  
  
  
  ReentrantLock lock = new ReentrantLock();
  ConditionThread ct1 = new ConditionThread(lock);
  ConditionThread ct2 = new ConditionThread(lock);
  Thread t1 = new Thread(ct1);
  t1.setName("C_Thread_1");
  Thread t2 = new Thread(ct2);
  t2.setName("C_Thread_2");
  
  t1.start();
  t2.start();
  
  try {
   Thread.sleep(1000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
  lock.lock();
  ct1.getCondition().signal();   //唤醒第一个线程
  lock.unlock();
 }

}