如何在Scala中的线程之间进行通信？

我在Scala中有一个包含一些方法的类，每个方法都有一个执行时间，例如

methodA

需要10秒，

methodB

需要5秒。当我调用

methodB

时，它应该取消运行其他方法的线程。我首先调用methodA，2秒钟后调用methodB。这个问题的最佳解决方案是什么

def methodA()={
    async{
        // a job that takes 10 seconds
    }
}
def methodB()={
   async{
       // other methods should stop their job
      // a job that takes 5 second
   }
}

def async[T](fn: => Unit): Unit = scala.actors.Actor.actor {
    fn
}

.....

methodA()
methodB()

---

以下是一个想法，基于您的方法正在积极检查它是否仍应运行或取消的假设：

import concurrent.{ExecutionContext, Future, Promise, blocking, future, promise}

case class Cancelled() extends RuntimeException

object Job {
  def apply[A](fun: (() => Boolean) => A)(implicit ctx: ExecutionContext): Job[A] = 
    new Job[A] {
      private val p = promise[A]
      def result = p.future
      def cancel(): Unit = p.tryFailure(Cancelled())

      p tryCompleteWith future {
        fun(() => !p.isCompleted)
      }
    }
}
trait Job[A] {
  def result: Future[A]
  def cancel(): Unit
}

因此

Job

与

cancel（）

方法一起体现了未来。您的示例可能与此类似：

import ExecutionContext.Implicits.global

val a = Job { active =>
  for (i <- 1 to 100 if active()) {
    blocking {
      Thread.sleep(1000)  // doing actual heavy work here
      println(s"A $i")
    }
  }
}

val b = Job { active =>
  for (i <- 1 to 20 if active()) {
    blocking {
      Thread.sleep(1000)  // doing actual heavy work here
      println(s"B $i")
    }
  }
  println("Goodbye A...")
  a.cancel()
}

import ExecutionContext.Implicits.global
val a=作业{active=>
为了
对于（我有一个很好的解决方案，但在我的项目中，线程或作业无法相互取消。在你的解决方案中，
b
知道有一个
a
jobAh，那么你只需要保存一个运行作业的全局列表。应该直接在
作业中注册它们。应用
方法。好的，但是标识符是什么应用方法中的作业是否在全局映射中注册？