调用者阻塞直到 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 未声明为volatile。

Answer 2

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

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

然后我会让 getFoo() 测试 foo 并且仅在它为非 null 时等待（不要忘记将其与自身和 foo 设置器同步）。

Answer 3

我会在java.util.concurrent 中使用BlockingQueue 中的任何一个，更具体地说，如果有一个线程在等待 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 都会期望notify。你想通知一次，然后再也不用通知通知，那么任何其他调用 getFoo 的线程要么阻塞，直到 foo 被初始化，要么只得到 foo（如果它已经初始化）。

Answer 5

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

这里是一个简单的例子：

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();
}
}