调用者会阻塞，直到 getFoo() 准备好值为止？

Question

我有一个 Java Thread ，它公开了其他线程想要访问的属性：

class MyThread extends Thread {
   private Foo foo;
   ...
   Foo getFoo() {
     return foo;
   }
   ...
   public void run() { 
     ...
     foo = makeTheFoo();
     ...
   }
}

问题是从运行到 foo 可用需要一些很短的时间。调用者可以在此之前调用 getFoo() 并获取 null。我宁愿他们简单地阻塞、等待，并在初始化发生后获取值。 （foo 此后永远不会更改。）准备就绪只需几毫秒，因此我对这种方法感到满意。

现在，我可以使用 wait() 和 notifyAll() 实现这一点，并且有 95% 的机会我会做对。但我想知道你们会怎么做？ java.util.concurrent 中是否有一个原语可以做到这一点，但我错过了？

或者，您将如何构建它？是的，让 foo 变得易失。是的，同步内部锁 Object 并将检查放入 while 循环中，直到它不为 null。我错过了什么吗？

Answer 1

如果 foo 仅初始化一次，则 CountDownLatch 非常适合。

class MyThread extends Thread {

  private final CountDownLatch latch = new CountDownLatch(1);

  ...

  Foo getFoo() throws InterruptedException
  {
    latch.await(); /* Or use overload with timeout parameter. */
    return foo;
  }

  @Override
  public void run() {
    foo = makeTheFoo()
    latch.countDown();
  }

}

锁存器提供与 volatile 关键字相同的可见性行为，这意味着读取线程将看到线程分配的 foo 值，即使 foo 也如此未声明易失性。

Answer 2

一般来说，notify() 和notifyAll() 是您想要的方法。如果只有一个项目正在创建 Foo 并且许多线程可能会等待它，则 notification() 是危险的。但我认为这里还存在一些其他问题。

我不会让 Thread 成为存储 Foo 的地方。这样做意味着您必须在创建 Foo 之后保留一个线程。为什么不创建另一个对象来存储 Foo，并让创建线程写入它？

然后我将 getFoo() 测试 foo 并仅在它非空时等待（不要忘记将其与其自身以及与 foo setter 同步）。

Answer 3

我会使用任何 < code>BlockingQueue 位于 java.util.concurrent 中 更具体地说，如果有一个线程在等待 Foo 并且有一个线程在生成它，我会使用 SynchronousQueue如果有更多生产者和/或更多消费者，我的默认选项是 LinkedBlockingQueue，但其他实现可能更适合您的应用程序。然后你的代码就变成：

class MyThread extends Thread {
   private SynchronousQueue<Foo> queue = new SynchronousQueue<Foo>();
   ...
   Foo getFoo() {
     Foo foo;
     try {
        foo = queue.take();
     }
     catch (InteruptedException ex) {
        ...stuff ...
     }
     return foo;
   }
   ...
   public void run() { 
     ...
     foo = makeTheFoo();
     try {
        queue.put(foo);
     }
     catch (InteruptedException ex) {
        ...stuff ...
     }
     ...
   }
}

Answer 4

尝试 CountDownLatch：

class MyThread extends Thread {
   private volatile CountDownLatch latch;
   private Foo foo;
   MyThread(){
      latch = new CountDownLatch(1);
   }
   ...
   Foo getFoo() {
     latch.await(); // waits until foo is ready
     return foo;
   }
   ...
   public void run() { 
     ...
     foo = makeTheFoo();
     latch.countDown();// signals that foo is ready
     ...
   }
}

我不认为 wait/notifyAll 会起作用，因为每个 wait 都会期望一个 <代码>通知。您希望通知一次，然后不再需要通知，那么调用 getFoo 的任何其他线程都会阻塞，直到 foo 初始化，或者只获取 foo code> 如果已经初始化。

Answer 5

您可以使用 wait() 和 notification() 方法：

简单示例：

http://www.java-samples.com/showtutorial.php?tutorialid=306

Answer 6

据我了解，并发的东西是明确创建的，不是为了立即等待并做你想做的事 - 但如果可能的话。在你的情况下，你需要等待直到有可用的东西，所以你唯一的选择是，呃，wait()。总之，看来你描述的方式是唯一正确的方式。

Answer 7

如果初始化是一次性的，请尝试 java .util.concurrent.CountDownLatch。

Answer 8

延迟初始化是一种选择吗？

synchronized Foo getFoo() {
    if (foo == null)
        foo = makeFoo();
    }
    return foo;
}

Answer 9

也许尝试一下我奇特的 FutureValue 课程......

import java.util.concurrent.CountDownLatch;

public class FutureValue<T> {
private CountDownLatch latch = new CountDownLatch(1);
private T value;

public void set(T value) throws InterruptedException, IllegalStateException {
    if (latch.getCount() == 0) {
        throw new IllegalStateException("Value has been already set.");
    }
    latch.countDown();
    this.value = value;
}

/**
 * Returns the value stored in this container. Waits if value is not available.
 * 
 * @return
 * @throws InterruptedException
 */
public T get() throws InterruptedException {
    latch.await();
    return value;
}

}

// Usage example
class MyExampleClass {
@SuppressWarnings("unused")
private static void usageExample() throws InterruptedException {
    FutureValue<String> futureValue = new FutureValue<>();

    // the thread that will produce the value somewhere
    new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                futureValue.set("this is future");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).run();

    String valueProducedSomewhereElse = futureValue.get();
}
}