Como não consegui encontrar uma implementação padrão dela, criei esta pequena classe, mas acho que algo simples como isso já deve existir em algum lugar:
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
}
}
O objetivo é trocar um valor entre dois threads (thread principal + EDT no meu caso). Pelo código que usa o método getValue (), parece quase um Future, mas as implementações Future que encontrei esperam que o chamador forneça o código a ser executado, o que não funciona no meu caso.
Então, minhas perguntas são:
A biblioteca padrão Scala fornece esse tipo de mecanismo de sincronização como scala.concurrent.SyncVar[T]classe.
Esta sessão Scala REPL demonstra como funciona:
scala> import concurrent._
import concurrent._
scala> import ops._
import ops._
Estou importando ops._para gerar outro Threadfacilmente.
scala> val syncInt = new SyncVar[Int]
syncInt: scala.concurrent.SyncVar[Int] = scala.concurrent.SyncVar@17823918
scala> spawn { println("got %d" format syncInt.get) }
Estou gerando outro tópico. getblocos até que haja um valor no syncInt.
scala> syncInt.isSet
res1: Boolean = false
scala> syncInt.set(103)
scala> got 103
O texto acima foi impresso pelo tópico que criamos antes.
scala> syncInt.isSet
res3: Boolean = true
scala> syncInt.get
res4: Int = 103
Este artigo é coletado da Internet.
Se houver alguma infração, entre em [email protected] Delete.
deixe-me dizer algumas palavras