condition是什么

条件（也称为条件队列或条件变量）为一个线程提供了一种暂停执行（“等待”）的方法，直到另一个线程通知某个状态条件现在可能为真。
Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。
不同的是，Object中的wait(),notify(),notifyAll()方法是和”同步锁“(synchronized关键字)捆绑使用的；而Condition是需要与”互斥锁“/“共享锁“(Lock)捆绑使用的。

Condition函数列表

  1. // 造成当前线程在接到信号或被中断之前一直处于等待状态。
  2. void await()
  3. // 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
  4. boolean await(long time, TimeUnit unit)
  5. // 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
  6. long awaitNanos(long nanosTimeout)
  7. // 造成当前线程在接到信号之前一直处于等待状态。
  8. void awaitUninterruptibly()
  9. // 造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。
  10. boolean awaitUntil(Date deadline)
  11. // 唤醒一个等待线程。
  12. void signal()
  13. // 唤醒所有等待线程。
  14. void signalAll()

实例

  1. public class ConditionTest {
  2.     public static void main(String[] args) {
  3.         final Business business = new Business();
  4.         final BusinessSynchronized businessSynchronized = new BusinessSynchronized();
  5.         new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 //threadExecute(business, "sub");
  9.                 threadExecuteSynchronized(businessSynchronized, "sub");
  10.             }
  11.         }).start();
  12.         //threadExecute(business, "main");
  13.         threadExecuteSynchronized(businessSynchronized, "main");
  14.     }
  16.     public static void threadExecute(Business business, String threadType) {
  17.         for (int i = 0; i < 2; i++) {
  18.             try {
  19.                 if ("main".equals(threadType)) {
  20.                     business.main(i);
  21.                 } else {
  22.                     business.sub(i);
  23.                 }
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         }
  28.     }
  30.     public static void threadExecuteSynchronized(BusinessSynchronized business, String threadType) {
  31.         for (int i = 0; i < 2; i++) {
  32.             try {
  33.                 if ("main".equals(threadType)) {
  34.                     business.main(i);
  35.                 } else {
  36.                     business.sub(i);
  37.                 }
  38.             } catch (InterruptedException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.     }
  43. }
  45. class Business {
  46.     private boolean bool = true;
  47.     private Lock lock = new ReentrantLock();
  48.     private Condition condition = lock.newCondition();
  50.     public /*synchronized*/ void main(int loop) throws InterruptedException {
  51.         lock.lock();
  52.         try {
  53.             while (bool) {
  54.                 condition.await();//this.wait();
  55.             }
  56.             for (int i = 0; i < 10; i++) {
  57.                 System.out.println("main thread seq of " + i + ", loop of " + loop);
  58.             }
  59.             bool = true;
  60.             condition.signal();//this.notify();
  61.         } finally {
  62.             lock.unlock();
  63.         }
  64.     }
  66.     public /*synchronized*/ void sub(int loop) throws InterruptedException {
  67.         lock.lock();
  68.         try {
  69.             while (!bool) {
  70.                 condition.await();//this.wait();
  71.             }
  72.             for (int i = 0; i < 10; i++) {
  73.                 System.out.println("sub thread seq of " + i + ", loop of " + loop);
  74.             }
  75.             bool = false;
  76.             condition.signal();//this.notify();
  77.         } finally {
  78.             lock.unlock();
  79.         }
  80.     }
  81. }
  83. class BusinessSynchronized {
  84.     private boolean bool = true;
  85.     //private Lock lock = new ReentrantLock();
  86.     //private Condition condition = lock.newCondition();
  88.     public synchronized void main(int loop) throws InterruptedException {
  89.         //lock.lock();
  90.         //try {
  91.             while (bool) {
  92.                 this.wait();
  93.             }
  94.             for (int i = 0; i < 10; i++) {
  95.                 System.out.println("main thread seq of " + i + ", loop of " + loop);
  96.             }
  97.             bool = true;
  98.             this.notify();
  99.         //} finally {
  100.         //    lock.unlock();
  101.         //}
  102.     }
  104.     public synchronized void sub(int loop) throws InterruptedException {
  105.         //lock.lock();
  106.         //try {
  107.             while (!bool) {
  108.                 this.wait();
  109.             }
  110.             for (int i = 0; i < 10; i++) {
  111.                 System.out.println("sub thread seq of " + i + ", loop of " + loop);
  112.             }
  113.             bool = false;
  114.             this.notify();
  115.         //} finally {
  116.         //    lock.unlock();
  117.         //}
  118.     }
  119. }

Condition和synchronized是一样的结果

  1. sub thread seq of 0, loop of 1
  2. sub thread seq of 1, loop of 1
  3. sub thread seq of 2, loop of 1
  4. sub thread seq of 3, loop of 1
  5. sub thread seq of 4, loop of 1
  6. sub thread seq of 5, loop of 1
  7. sub thread seq of 6, loop of 1
  8. sub thread seq of 7, loop of 1
  9. sub thread seq of 8, loop of 1
  10. sub thread seq of 9, loop of 1
  11. main thread seq of 0, loop of 1
  12. main thread seq of 1, loop of 1
  13. main thread seq of 2, loop of 1
  14. main thread seq of 3, loop of 1
  15. main thread seq of 4, loop of 1
  16. main thread seq of 5, loop of 1
  17. main thread seq of 6, loop of 1
  18. main thread seq of 7, loop of 1
  19. main thread seq of 8, loop of 1
  20. main thread seq of 9, loop of 1
  22. 进程已结束,退出代码0

Object监视器方法与Condition接口最大区别
Object监视器的等待队列个数只有一个，但是Condition等待队列可以为多个；
我们接下来把Condition的API代码拿出来看看：

  1. public class SynchronizedTest {
  2.     public static void main(String[] args) {
  3.         BoundedBuffer boundedBuffer = new BoundedBuffer();
  4.         for (int i = 0; i < 5; i++) {
  5.             int finalI = i;
  6.             new Thread(() -> {
  7.                 try {
  8.                     boundedBuffer.put(finalI);
  9.                 } catch (InterruptedException e) {
  10.                     e.printStackTrace();
  11.                 }
  12.             }
  14.             ).start();
  15.         }
  16.         for (int i = 10; i < 15; i++) {
  17.             int finalI = i;
  18.             new Thread(() -> {
  19.                 try {
  20.                     boundedBuffer.put(finalI);
  21.                 } catch (InterruptedException e) {
  22.                     e.printStackTrace();
  23.                 }
  24.             }
  26.             ).start();
  27.         }
  28.         try {
  29.             for (int i = 0; i < 15; i++) {
  30.                 System.out.println(boundedBuffer.take());
  31.             }
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36. }
  39. class BoundedBuffer {
  40.     final Lock lock = new ReentrantLock();//锁对象
  41.     final Condition notFull = lock.newCondition();//写线程条件
  42.     final Condition notEmpty = lock.newCondition();//读线程条件
  44.     final Object[] items = new Object[100];//缓存队列
  45.     int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;
  47.     public void put(Object x) throws InterruptedException {
  48.         lock.lock();
  49.         try {
  50.             while (count == items.length)//如果队列满了
  51.                 notFull.await();//阻塞写线程
  52.             items[putptr] = x;//赋值
  53.             if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0
  54.             ++count;//个数++
  55.             notEmpty.signal();//唤醒读线程
  56.         } finally {
  57.             lock.unlock();
  58.         }
  59.     }
  61.     public Object take() throws InterruptedException {
  62.         lock.lock();
  63.         try {
  64.             while (count == 0)//如果队列为空
  65.                 notEmpty.await();//阻塞读线程
  66.             Object x = items[takeptr];//取值
  67.             if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0
  68.             --count;//个数--
  69.             notFull.signal();//唤醒写线程
  70.             return x;
  71.         } finally {
  72.             lock.unlock();
  73.         }
  74.     }
  75. }

我们执行一下：
image.png
可以看到这是一个等待队列，FIFO的队列