Scala - multithreading, finish main thread when any child thread finishes - multithreading

Question

I am building a method that takes x-sized sequence of methods and returns the result of the first method to finish.
def invokeAny(work: Seq[() => Int]): Int = ???
How can I accomplish this by using Threads? (no futures allowed)
This is the best I have been able to come up with, but seems not to work in all circumstances.
def invokeAny(work: Seq[() => Int]): Int = {
#volatile var result = 0 // set to return value of any work function
val main = Thread.currentThread()
val threads: Seq[Thread] = work.map(work => new Thread( new Runnable {
def run { result = work(); main.interrupt(); }}))
threads.foreach(_.start())
for(thread <- threads) {
try {
thread.join()
} catch {
// We've been interrupted: finish
case e: InterruptedException => return result
}
}
return result
}

Answer 1

Not the pretiest answer, but seemed to work:
def invokeAny(work: Seq[() => Int]): Int = {
#volatile var result = 0 // set to return value of any work function
val main = Thread.currentThread()
var threads: Seq[Thread] = Seq()
//Interrupts all threads after one is interrupted
def interruptAll = {
main.interrupt()
for(thread <- threads) {
thread.interrupt()
}
}
threads = work.map(work => new Thread(
new Runnable {
def run {
result = try {
work() } catch {
case e:InterruptedException => return
}
interruptAll;
}
}))
threads.foreach(_.start())
for(thread <- threads) {
try {
thread.join()
} catch {
// We've been interrupted: finish
case e: InterruptedException => return result
}
}
return result
}

Answer 2

Using a BlockingQueue, no shared mutable state, worker threads write to a queue, the main threads wait till they finish and read from the queue then do something with the results like sum
def invokeAny1(work: Seq[() => Int]): Int = {
val queue = new ArrayBlockingQueue[Int](work.size)
val threads: Seq[Thread] = work.map(w => new Thread( new Runnable {
def run {
val result= w()
queue.put(result) }}))
threads.foreach(_.start())
threads.foreach(_.join())
var sum:Int=0
while(!queue.isEmpty) {
sum +=queue.take()
}
sum
}
Using a CountDownLatch.
Worker threads increment an atomic variable.
When all the threads are done the latch is released and the main thread can read the data from the atomic variable
def invokeAny2(work: Seq[() => Int]): Int = {
val total=new AtomicInteger
val latch= new CountDownLatch(work.size)
val threads: Seq[Thread] = work.map(w => new Thread( new Runnable {
def run {
val result= w()
total.getAndAdd(result)
latch.countDown
}}))
threads.foreach(_.start())
latch.await //wait till the latch is released
total.get
}
}