java 线程 Lock 锁使用Condition实现线程的等待（await）与通知(signal)详解编程语言

public interface Condition { 
     //使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁。与Object.wait()类似。 
    void await() throws InterruptedException; 
 
    //调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。 
    //调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。  
    void awaitUninterruptibly(); 
 
    // 调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。 
    //nanosTimeout指定该方法等待信号的的最大时间（单位为纳秒）。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间； 
    //若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。  
    long awaitNanos(long nanosTimeout) throws InterruptedException; 
 
    //与await()基本一致，唯一不同点在于，指定时间之内没有收到signal()或signalALL()信号或者线程中断时该方法会返回false;其它情况返回true。 
    boolean await(long time, TimeUnit unit) throws InterruptedException; 
 
   //适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻。 
    boolean awaitUntil(Date deadline) throws InterruptedException; 
     
    //唤醒一个在 await()等待队列中的线程。与Object.notify()相似 
    void signal(); 
 
   //唤醒 await()等待队列中所有的线程。与object.notifyAll()相似 
    void signalAll(); 
}

 package com.jalja.org.base.Thread; 
  
 import java.util.concurrent.TimeUnit; 
 import java.util.concurrent.locks.Condition; 
 import java.util.concurrent.locks.ReentrantLock; 
  
 /** 
  * Condition 配合Lock  实现线程的等待 与通知 
  */ 
 public class ConditionTest{ 
     public static ReentrantLock lock=new ReentrantLock(); 
     public static Condition condition =lock.newCondition(); 
     public static void main(String[] args) { 
         new Thread(){ 
             @Override 
             public void run() { 
                 lock.lock();//请求锁 
                 try{ 
                     System.out.println(Thread.currentThread().getName()+"==》进入等待"); 
                     condition.await();//设置当前线程进入等待 
                 }catch (InterruptedException e) { 
                     e.printStackTrace(); 
                 }finally{ 
                     lock.unlock();//释放锁 
                 } 
                 System.out.println(Thread.currentThread().getName()+"==》继续执行"); 
             }     
         }.start(); 
         new Thread(){ 
             @Override 
             public void run() { 
                 lock.lock();//请求锁 
                 try{ 
                     System.out.println(Thread.currentThread().getName()+"=》进入"); 
                     Thread.sleep(2000);//休息2秒 
                     condition.signal();//随机唤醒等待队列中的一个线程 
                     System.out.println(Thread.currentThread().getName()+"休息结束"); 
                 }catch (InterruptedException e) { 
                     e.printStackTrace(); 
                 }finally{ 
                     lock.unlock();//释放锁 
                 } 
             }     
         }.start(); 
     } 
 }

Thread-0==》进入等待 
Thread-1=》进入 
Thread-1休息结束 
Thread-0==》继续执行

  public void put(E e) throws InterruptedException { 
        checkNotNull(e);//对传入元素的null判断 
        final ReentrantLock lock = this.lock; 
        lock.lockInterruptibly();//对put()方法做同步 
        try { 
            while (count == items.length)//如果队列已满 
                notFull.await();//让当前添加元素的线程进入等待状态 
            insert(e);// 如果有其他线程调用signal() 通知该线程 ，则进行添加行为 
        } finally { 
            lock.unlock();//释放锁 
        } 
    } 
     
    private E extract() { 
        final Object[] items = this.items; 
        E x = this.<E>cast(items[takeIndex]); 
        items[takeIndex] = null; 
        takeIndex = inc(takeIndex); 
        --count; 
        notFull.signal();//唤醒一个在Condition等待队列中的线程 
        return x; 
    }