我已经和Akka一起工作了一段时间，但是现在正在深入探索它的演员系统。我知道有线程轮询执行器和fork join执行器和affinity执行器。我知道调度器是如何工作的，以及所有其他细节。顺便说一句，这个链接给出了一个很好的解释
https://scalac.io/improving-akka-dispatchers
然而，当我用一个简单的调用参与者进行实验并切换执行上下文时，我总是得到大致相同的性能。我同时运行60个请求，平均执行时间大约为800毫秒，只是向调用者返回一个简单的字符串。
我运行的MAC有8个核心（英特尔i7处理器）.
下面是我尝试过的执行上下文：

thread-poll {
  type = Dispatcher
  executor = "thread-pool-executor"
  thread-pool-executor {
    fixed-pool-size = 32
  }
  throughput = 10
}

fork-join {
  type = Dispatcher
  executor = "fork-join-executor"
  fork-join-executor {
    parallelism-min = 2
    parallelism-factor = 1
    parallelism-max = 8
  }
  throughput = 100
}

pinned {
  type = Dispatcher
  executor = "affinity-pool-executor"
}

所以，问题是：
1.在这个例子中，是否有机会获得更好的性能？
1.参与者示例是怎么回事？如果我们知道调度程序正在调度线程（使用执行上下文），以便在该线程内对来自参与者邮箱的下一条消息执行参与者的receive方法，这有什么关系呢？参与者的receive方法不只是像回调一样吗？参与者示例的数量何时开始起作用？
1.我有一些执行Future的代码，如果我直接从主文件运行该代码，它的执行速度比我把它放在actors中并从actors执行Future时快100-150毫秒，并将其结果传送到发送方。是什么使它变慢了？
如果你有一些真实的世界的例子来解释这一点，那是非常受欢迎的。我读了一些文章，但都是理论上的。如果我在一个简单的例子上尝试一些东西，我会得到一些意想不到的结果，在性能方面。
这里有一个代码

object RedisService {
  case class Get(key: String)
  case class GetSC(key: String)
}

class RedisService extends Actor {
  private val host = config.getString("redis.host")
  private val port = config.getInt("redis.port")

  var currentConnection = 0

  val redis = Redis()

  implicit val ec = context.system.dispatchers.lookup("redis.dispatchers.fork-join")

  override def receive: Receive = {
    case GetSC(key) => {
      val sen = sender()

      sen ! ""
    }
  }
}

来电者：

val as = ActorSystem("test")
    implicit val ec = as.dispatchers.lookup("redis.dispatchers.fork-join")

    val service = as.actorOf(Props(new RedisService()), "redis_service")

    var sumTime = 0L
    val futures: Seq[Future[Any]] = (0 until 4).flatMap { index =>
      terminalIds.map { terminalId =>
        val future = getRedisSymbolsAsyncSCActor(terminalId)

        val s = System.currentTimeMillis()
        future.onComplete {
          case Success(r) => {
            val duration = System.currentTimeMillis() - s
            logger.info(s"got redis symbols async in ${duration} ms: ${r}")
            sumTime = sumTime + duration
          }
          case Failure(ex) => logger.error(s"Failure on getting Redis symbols: ${ex.getMessage}", ex)
        }

        future
      }
    }

    val f = Future.sequence(futures)

    f.onComplete {
      case Success(r) => logger.info(s"Mean time: ${sumTime / (4 * terminalIds.size)}")
      case Failure(ex) => logger.error(s"error: ${ex.getMessage}")
    }

代码非常基本，只是为了测试它的行为。