chapter14_构建自定义的同步工具_3_显式的Condition对象

最新推荐文章于 2024-09-17 18:44:25 发布

原创最新推荐文章于 2024-09-17 18:44:25 发布 · 171 阅读

0 ·

CC 4.0 BY-SA版权

《Java并发编程实战》学习笔记专栏收录该内容

58 篇文章

订阅专栏

博客介绍了Java中Condition接口，它是广义的条件队列，在java.util.concurrent.locks包中。可代替原生条件队列，一个Condition对象与Lock对象关联，Lock可关联多个Condition。使用时要用await、signal、signalAll方法，示例展示了使用Condition的优点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

(1) Condition是一种广义的条件队列

(2) 在java.util.concurrent.locks包中, Condition是一个接口
```
  public interface Condition {

      void await() throws InterruptedException;

      void awaitUninterruptibly();

      long awaitNanos(long nanosTimeout) throws InterruptedException;

      boolean await(long time, TimeUnit unit) throws InterruptedException;

      boolean awaitUntil(Date deadline) throws InterruptedException;

      void signal();

      void signalAll();
  }
```
(3) 如果想编写一个带有多个条件谓词的并发对象, 或者想获得更多对条件队列的控制权, 那么就可以考虑用Condition代替原生条件队列

(4) 一个Condition对象和一个Lock对象关联在一起(就像一个条件队列和一个内置锁关联一样);

但是一个Lock对象可以关联任意数量的Condition对象(通过Lock的Condition newCondition();方法)

(5) Condition对象继承了相关的Lock对象的公平性(如果Lock是公平的, 那么线程会按照FIFO从Condition的await中释放)

(6) wait、notify、notifyAll是Object的方法, 由于Object是所有类的基类, 所以Condition的实现类也有这三个方法. __但是, 使用Condition要用它的await、signal、signalAll方法

(1) 示例

  @ThreadSafe
  public class ConditionBoundedBuffer<T> {

      private static final int BUFFER_SIZE = 100;

      protected final Lock lock = new ReentrantLock();

      // CONDITION PREDICATE: notFull (count < items.length)
      private final Condition notFull = lock.newCondition();

      // CONDITION PREDICATE: notEmpty (count > 0)
      private final Condition notEmpty = lock.newCondition();

      @GuardedBy("lock")
      private final T[] items = (T[]) new Object[BUFFER_SIZE];

      @GuardedBy("lock")
      private int tail, head, count;

      // BLOCKS-UNTIL: notFull
      public void put(T x) throws InterruptedException {

          lock.lock();

          try {
              while (count == items.length) {
                  notFull.await();
              }

              items[tail] = x;

              if (++tail == items.length) {
                  tail = 0;
              }

              ++count;
              notEmpty.signal();

          } finally {

              lock.unlock();
          }
      }

      // BLOCKS-UNTIL: notEmpty
      public T take() throws InterruptedException {

          lock.lock();

          try {
              while (count == 0) {
                  notEmpty.await();
              }

              T x = items[head];
              items[head] = null;

              if (++head == items.length) {
                  head = 0;
              }

              --count;

              notFull.signal();

              return x;

          } finally {

              lock.unlock();
          }
      }
  }

(2) 这个示例使用Condition, 优点有两个: