scala - Akka Http 性能调优

Question

我正在Akka-http框架(版本:10.0)上进行负载测试，我使用wrk工具。wrk命令:

wrk -t6 -c10000 -d 60s --timeout 10s --latency http://localhost:8080/hello

首次运行时没有任何阻塞调用，

object WebServer {

  implicit val system = ActorSystem("my-system")
  implicit val materializer = ActorMaterializer()
  implicit val executionContext = system.dispatcher
  def main(args: Array[String]) {


    val bindingFuture = Http().bindAndHandle(router.route, "localhost", 8080)

    println(
      s"Server online at http://localhost:8080/\nPress RETURN to stop...")
    StdIn.readLine() // let it run until user presses return
    bindingFuture
      .flatMap(_.unbind()) // trigger unbinding from the port
      .onComplete(_ => system.terminate()) // and shutdown when done
  }
}

object router {
  implicit val executionContext = WebServer.executionContext


  val route =
    path("hello") {
      get {
        complete {
        "Ok"
        }
      }
    }
}

wrk的输出:

    Running 1m test @ http://localhost:8080/hello
  6 threads and 10000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     4.22ms   16.41ms   2.08s    98.30%
    Req/Sec     9.86k     6.31k   25.79k    62.56%
  Latency Distribution
     50%    3.14ms
     75%    3.50ms
     90%    4.19ms
     99%   31.08ms
  3477084 requests in 1.00m, 477.50MB read
  Socket errors: connect 9751, read 344, write 0, timeout 0
Requests/sec:  57860.04
Transfer/sec:      7.95MB

现在，如果我在 route 添加 future 的调用并再次运行测试。

val route =
    path("hello") {
      get {
        complete {
          Future { // Blocking code
            Thread.sleep(100)
            "OK"
          }
        }
      }
    }

输出，wrk:

Running 1m test @ http://localhost:8080/hello
  6 threads and 10000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   527.07ms  491.20ms  10.00s    88.19%
    Req/Sec    49.75     39.55   257.00     69.77%
  Latency Distribution
     50%  379.28ms
     75%  632.98ms
     90%    1.08s 
     99%    2.07s 
  13744 requests in 1.00m, 1.89MB read
  Socket errors: connect 9751, read 385, write 38, timeout 98
Requests/sec:    228.88
Transfer/sec:     32.19KB

正如您在未来的调用中所看到的，仅正在处理 13744 个请求。

关注 Akka documentation 后，我为创建最多 200 个线程的路由添加了一个单独的调度程序线程池。

implicit val executionContext = WebServer.system.dispatchers.lookup("my-blocking-dispatcher")
// config of dispatcher
my-blocking-dispatcher {
  type = Dispatcher
  executor = "thread-pool-executor"
  thread-pool-executor {
    // or in Akka 2.4.2+
    fixed-pool-size = 200
  }
  throughput = 1
}

经过上述改动后，性能有所提升

Running 1m test @ http://localhost:8080/hello
  6 threads and 10000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   127.03ms   21.10ms 504.28ms   84.30%
    Req/Sec   320.89    175.58   646.00     60.01%
  Latency Distribution
     50%  122.85ms
     75%  135.16ms
     90%  147.21ms
     99%  190.03ms
  114378 requests in 1.00m, 15.71MB read
  Socket errors: connect 9751, read 284, write 0, timeout 0
Requests/sec:   1903.01
Transfer/sec:    267.61KB

在 my-blocking-dispatcher 配置中，如果我将池大小增加到 200 以上，性能是相同的。

现在，我应该使用哪些其他参数或配置来提高使用 future 调用时的性能。以便该应用程序提供最大吞吐量。

Answer 1

首先是一些免责声明:我以前没有使用过 wrk 工具，所以我可能会出错。以下是我对此答案所做的假设:

1. 连接数与线程数无关，即，如果我指定 -t4 -c10000，它将保留 10000 个连接，而不是 4 * 10000。
2. 对于每个连接，行为如下:发送请求，完全接收响应，然后立即发送下一个连接，依此类推，直到时间用完。

另外，我在与wrk相同的机器上运行服务器，而我的机器似乎比你的弱(我只有双核CPU)，所以我将wrk的线程数减少到2，连接数减少到 1000，以获得不错的结果。

我使用的Akka Http版本是10.0.1，wrk版本是4.0.2。

现在给出答案。让我们看看您的阻止代码:

Future { // Blocking code
  Thread.sleep(100)
  "OK"
}

这意味着，每个请求至少需要 100 毫秒。如果你有 200 个线程和 1000 个连接，时间线将如下:

Msg: 0       200      400      600      800     1000     1200      2000
     |--------|--------|--------|--------|--------|--------|---..---|---...
Ms:  0       100      200      300      400      500      600      1000

其中 Msg 是已处理的消息量，Ms 是耗时(以毫秒为单位)。

这使我们每秒处理 2000 条消息，或每 30 秒约 60000 条消息，这与测试数据基本一致:

wrk -t2 -c1000 -d 30s --timeout 10s --latency http://localhost:8080/hello
Running 30s test @ http://localhost:8080/hello
  2 threads and 1000 connections
  Thread Stats   Avg     Stdev     Max   +/- Stdev
    Latency   412.30ms   126.87ms 631.78ms   82.89%
    Req/Sec     0.95k    204.41     1.40k    75.73%
  Latency Distribution
     50%  455.18ms
     75%  512.93ms
     90%  517.72ms
     99%  528.19ms
here: --> 56104 requests in 30.09s <--, 7.70MB read
  Socket errors: connect 0, read 1349, write 14, timeout 0
Requests/sec:   1864.76
Transfer/sec:    262.23KB

同样明显的是，这个数字(每秒 2000 条消息)受到线程数的严格限制。例如。如果我们有 300 个线程，那么我们每 100 毫秒就会处理 300 条消息，因此如果我们的系统可以处理这么多线程，那么我们每秒就会处理 3000 条消息。让我们看看如果我们为每个连接提供 1 个线程(即池中 1000 个线程)，效果如何:

wrk -t2 -c1000 -d 30s --timeout 10s --latency http://localhost:8080/hello
Running 30s test @ http://localhost:8080/hello
  2 threads and 1000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   107.08ms   16.86ms 582.44ms   97.24%
    Req/Sec     3.80k     1.22k    5.05k    79.28%
  Latency Distribution
     50%  104.77ms
     75%  106.74ms
     90%  110.01ms
     99%  155.24ms
  223751 requests in 30.08s, 30.73MB read
  Socket errors: connect 0, read 1149, write 1, timeout 0
Requests/sec:   7439.64
Transfer/sec:      1.02MB

如您所见，现在一个请求平均需要几乎正好 100 毫秒，即与我们放入 Thread.sleep 中的时间相同。看来我们不能比这更快了!现在我们几乎处于每个请求一个线程的标准情况，这种情况多年来一直运行良好，直到异步 IO 让服务器扩展得更高。

为了进行比较，以下是我的机器上使用默认 fork-join 线程池的完全非阻塞测试结果:

complete {
  Future {
    "OK"
  }
}

====>

wrk -t2 -c1000 -d 30s --timeout 10s --latency http://localhost:8080/hello
Running 30s test @ http://localhost:8080/hello
  2 threads and 1000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    15.50ms   14.35ms 468.11ms   93.43%
    Req/Sec    22.00k     5.99k   34.67k    72.95%
  Latency Distribution
     50%   13.16ms
     75%   18.77ms
     90%   25.72ms
     99%   66.65ms
  1289402 requests in 30.02s, 177.07MB read
  Socket errors: connect 0, read 1103, write 42, timeout 0
Requests/sec:  42946.15
Transfer/sec:      5.90MB

总而言之，如果您使用阻塞操作，则每个请求需要一个线程才能实现最佳吞吐量，因此请相应地配置线程池。您的系统可以处理的线程数量存在自然限制，您可能需要调整操作系统以获得最大线程数。为了获得最佳吞吐量，请避免阻塞操作。

另外，不要将异步操作与非阻塞操作混淆。您的带有 Future 和 Thread.sleep 的代码是异步但阻塞操作的完美示例。许多流行的软件都在这种模式下运行(一些旧版 HTTP 客户端、Cassandra 驱动程序、AWS Java SDK 等)。要充分获得非阻塞 HTTP 服务器的优势，您需要自始至终都是非阻塞的，而不仅仅是异步的。这可能并不总是可能的，但这是值得努力的事情。