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

以上内容已由我们之前创建的主题打印出来。

{{1}}

Answer 2

看起来有点类似synchronous queue有一个元素，消费者必须wait才能让生产者提供价值。

Answer 3

对我来说，它看起来像Exchanger一样位，除了它更片面......你看过那个吗？基本上你不必担心你从“等待”方面提供的内容，或者你从“提供”部分收到的内容。

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

Answer 4

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

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

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

Answer 5

这与flow programming有些相关。

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

5 个答案: