scala – Akka Http性能调优

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

现在如果我在路由中添加未来呼叫并再次运行测试.

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,timeout 0
Requests/sec:   1903.01
Transfer/sec:    267.61KB

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

现在,我应该使用什么其他参数或配置来增加使用将来的调用时的性能.因此该应用程序可以提供最大的吞吐量.