使用Scala参与者执行CPU限制的任务？

假设我必须完成几个CPU限制的任务。例如，如果我有4个CPU，我可能会创建一个固定大小的线程池，其中有4-5个工作线程在队列中等待，并将任务放入队列中。在Java中，我可以使用

Java.util.concurrent

（可能是

ThreadPoolExecutor

）来实现这个机制

---

您将如何使用Scala actors实现它？

嗯，您通常不会。使用演员的部分吸引力在于他们为你处理这些细节

---

但是，如果您坚持要管理它，则需要重写

Actor

类上受保护的

scheduler

方法以返回适当的值。另请参见，以及有关调度程序的注释。

所有参与者基本上都是线程，由调度程序在引擎盖下执行。调度器创建一个线程池，以执行大致绑定到内核数量的参与者。这意味着您只需为需要执行的每个任务创建一个参与者，其余任务由Scala完成：

for(i <- 1 to 20) {
  actor {
    print(i); 
    Thread.sleep(1000);
  }
}

用于（i）
演员{
循环{
反应{
案例x:String=>println（x）
} 
}
}
}
为了
//一些计算上昂贵的东西
t、 执行
案例=>println（“Akka中需要默认案例…”）
}
}
类TaskRouter（numWorkers:Int）使用LoadBalancer扩展了Actor{
val workerPool=Vector.fill（numWorkers）（actorOf[TaskHandler].start（））
val seq=新循环器（workerPool）
}
val router=actorOf（新任务路由器（4））.start（）
例如（我试过Scala Actors或并行集合吗？它们已经可以在不同的CPU上分配工作负载了。如果您需要更多的控制，可以查看Akka。
import scala.actors.Actor._

val numWorkers = 4
val pool = (1 to numWorkers).map { i =>
  actor { 
    loop { 
      react { 
        case x: String => println(x) 
      } 
    }
  }
}

for(i <- 1 to 20) {
  val r = (new util.Random).nextInt(numWorkers)
  pool(r) ! "task "+i
}

import akka.actor.Actor
import Actor._
import akka.routing.{LoadBalancer, CyclicIterator}

class TaskHandler extends Actor {
  def receive = {
    case t: Task =>
      // some computationally expensive thing
      t.execute
    case _ => println("default case is required in Akka...")
  }
}

class TaskRouter(numWorkers: Int) extends Actor with LoadBalancer {
   val workerPool = Vector.fill(numWorkers)(actorOf[TaskHandler].start())
   val seq = new CyclicIterator(workerPool)
}

val router = actorOf(new TaskRouter(4)).start()

for(i <- 1 to 20) {
  router ! Task(..)
}