Java的LockSupport工具，Condition接口和ConditionObject LockSupportConditionConditionObject

package java.util.concurrent.locks;
import sun.misc.Unsafe;

public class LockSupport {
    private LockSupport() {} // Cannot be instantiated.
    
    
    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }

    //唤醒处于阻塞状态的线程
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

    //阻塞调用此方法的线程，这个的参数是阻塞对象，用来表示当前线程在等待的对象，
    //用于排查和系统监控（这个在Java6后添加的，同期还添加了parkNanos方法和parkUtil方法，里面都含有blocker参数）
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }
    //阻塞当前线程最长不超过nanos纳秒
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            UNSAFE.park(false, nanos);
            setBlocker(t, null);
        }
    }
    
    //阻塞当前线程直到deadline
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

    //获取阻塞对象
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    //阻塞线程
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    //阻塞当前线程最长不超过nanos纳秒
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }
    
    //阻塞当前线程直到deadline（无阻塞对象参数）
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

   
    static final int nextSecondarySeed() {
        int r;
        Thread t = Thread.currentThread();
        if ((r = UNSAFE.getInt(t, SECONDARY)) != 0) {
            r ^= r << 13;   // xorshift
            r ^= r >>> 17;
            r ^= r << 5;
        }
        else if ((r = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    // Hotspot implementation via intrinsics API
    private static final sun.misc.Unsafe UNSAFE;
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }
}

public interface Condition {
    
    //当前线程进入等待状态，直到被通知或中断
    void await() throws InterruptedException;
    
    //当前线程进入等待状态，直到被通知或中断（对中断不敏感）
    void awaitUninterruptibly();

    //当前线程进入等待状态，直到被通知，中断或超时
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    //当前线程进入等待状态，直到被通知，中断或超时（注意这个返回值是boolean）
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    //当前线程进入等待状态，直到被通知，中断或到某个时间
    boolean awaitUntil(Date deadline) throws InterruptedException;
    
    //唤醒一个在Condition上的线程
    void signal();
    
    //唤醒所有在Condition上的线程
    void signalAll();
}

    Lock lock = new ReentrantLock();
    Condition c = lock.newCondition();

 public Condition newCondition() {
        return sync.newCondition();
    }

 final ConditionObject newCondition() {
            return new ConditionObject();
    }

 public class ConditionObject implements Condition, 
 java.io.Serializable {
     .
     .
     .
}

 public class ConditionObject implements Condition, 
 java.io.Serializable {
 {

    //头结点和尾节点
    private transient Node firstWaiter;
    private transient Node lastWaiter;

  public ConditionObject() { }

    public final void await() throws InterruptedException {
            //当前线程中断抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();
            //为调用await 方法创建节点
            Node node = addConditionWaiter();
            //释放同步状态，fullyRelease里面会调用释放方法，
            //同时唤醒同步队列的下一个节点
            int savedState = fullyRelease(node);
            //下面是对监控变量做的改变
            int interruptMode = 0;
            //如果节点不在同步队列中
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //只有成功获取锁后，调用await方法的线程才能用await方法返回
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

private Node addConditionWaiter() {
            //获取尾节点
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            //为线程创建新节点
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            //返回这个新节点
            return node;
        }

  public final void signal() {
            //如果当前线程未获取锁，抛出异常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            //获取同步队列的首节点
            Node first = firstWaiter;
            //如果头结点不为空，那么将它移动到同步队列并使用LockSupport唤醒
            if (first != null)
                doSignal(first);
        }

  private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
                //transferForSignal方法将等待队列节点重新包装成Node节点
                //加入同步队列
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }