这种并发相关的类怎么称呼呢？是否有标准实施？

Question

因为我找不到它的标准实现，所以我创建了这个小类，但我认为一些简单的东西应该已经存在于某个地方：

class ReturnValue {
    private var value = false

    private val latch = new java.util.concurrent.CountDownLatch(1)

    def setValue(aValue: Boolean) {
        value = aValue
        latch.countDown()
    }
    def getValue() = {
        latch.await
        value
    }
}

它的目的是在两个线程之间交换值（在我的例子中是主线程+ EDT） 。从使用 getValue() 方法的代码来看，它看起来几乎像一个 Future，但我发现 Future 实现期望调用者提供要执行的代码，这在我的情况下不起作用。

所以我的问题是：

• 这样的东西有名字吗？
• java 或 scala 中有标准实现吗？
• 我的实现是否正确？

Answer 1

Scala 标准库提供了这种同步机制作为 scala.concurrent.SyncVar[T] 类。

此 Scala REPL 会话演示了它的工作原理：

scala> import concurrent._           
import concurrent._

scala> import ops._                  
import ops._

我导入 ops._ 来轻松生成另一个 Thread。

scala> val syncInt = new SyncVar[Int]
syncInt: scala.concurrent.SyncVar[Int] = scala.concurrent.SyncVar@17823918

scala> spawn { println("got %d" format syncInt.get) }

我正在生成另一个线程。 get 会阻塞，直到 syncInt 中有一个值。

scala> syncInt.isSet
res1: Boolean = false

scala> syncInt.set(103)

scala> got 103

上面的内容已经被我们之前创建的线程打印出来了。

scala> syncInt.isSet
res3: Boolean = true

scala> syncInt.get
res4: Int = 103

Answer 2

看起来有点类似于同步队列 使用一个元素，消费者必须 等待生产者提供一个值。

Answer 3

这看起来有点像

我同意你的观点，除了“可执行”部分之外，它看起来像是一个未来。

Answer 4

我创建了一个非常相似的东西，称为 BlockingReference，我需要消费者（一个或多个）能够读取最新的值或块，直到有一个可用为止。本质上，它就像一个单元素队列，因为生产者线程可以随时发布新值然后继续。当唯一需要发布的信息是某种状态更新时，它是相关的。我用它来标记多线程内容分发缓存中的进度（其中一个线程下载内容，并且有多个消费者重新广播下载的字节）。与您的主要区别在于您的设备是一次性的。

此实现明显优于 SynchronousQueue 和 Exchanger，因为它们都会阻塞生产者线程，直到发生切换。它在性能上优于 Scala SyncVar ，因为生产者线程是在没有任何阻塞的情况下实现的，并且在功能上优于 Scala SyncVar ，因为它可以支持多个消费者。它已进行了大量性能优化。

Atlassian Concurrency 库已获得 Apache2 许可，并且位于我们的公共 Maven 存储库中。

Answer 5

这与流编程有些关系。