scala - SecureSocial : Running DB IO in a separate thread pool

Question

我有一个使用 play-slick 0.5.0.8 的 Play 2.2.1 应用程序将数据持久化到 Postgresql 后端和 SecureSocial 2.1.2处理用户授权。

由于巧妙的交易被阻塞，我创建了一个单独的 slick-context我的 /conf/application.conf 中的执行上下文文件，根据 instructions found in the plugin's Wiki :

play {
  akka {
    actor {
      slick-context = {
        fork-join-executor {
          parallelism-min = 300
          parallelism-max = 300
        }
      }
    }
  }
}

这允许我创建一个在单独的执行上下文中运行的 Controller Action，并且不会阻塞默认线程池中的线程。例如。 /app/controllers/Application.scala :

示例一 - 使用 play-slick 的 DBAction:

import play.api.db.slick._
object Application extends Controller{ 

  // this controller Action won't block threads in the default pool since DBAction uses my separate slick-context execution context
  def recipes = DBAction { implicit rs =>
    val recipes  = Query(Recipes).list
    Ok(recipes.mkString)
  }

}

对于某些 Controller 操作，我希望能够将 SecureSocial 的操作( SecuredAction 、 UserAwareAction 等)与 play-slick 的 DBAction 结合使用.将两者结合起来的最佳方法是什么？

我意识到我可以做类似下面的事情，但我的理解是数据库调用不会使用我单独的 slick-context因此会阻塞默认线程池:

示例二 - 使用 SecureSocial 的操作:

import play.api.db.slick._
import securesocial.core._
object Application extends Controller{ 

  // changing from a DBAction to a SecuredAction so that I can use SS's goodies
  def recipes = SecuredAction { implicit request =>
    val recipes  =  DB.withSession { implicit session:Session => Query(Recipes).list } // i'm guessing this WILL BLOCK the default thread pool since it isn't using my separate slick-context execution context??
    Ok(recipes.mkString)
  }

}

我假设示例二将使用/阻止默认线程池而不是我单独的 slick-context 是否正确？线程池？如果是这样，有没有办法改变这种情况？

我显然可以通过 bumping up Play's default thread pool 解决这个问题( default-dispatcher )，但理想情况下，我希望保持默认线程池相当精简，并在单独的池中运行所有阻塞 DB 调用。

帮助表示赞赏!

Answer 1

要回答你的问题，

Am I correct in assuming that Example Two will use/block the default thread pool instead of my separate slick-context thread pool? If so,

是的，这会耗尽/阻止默认池。

如果您想使用单独的 slick-context线程池，那么你可以尝试这样的事情吗？

  import scala.concurrent.Future

  // Note the use of '.async' |
  //                          V
  def recipes = SecuredAction.async { implicit request =>
    Future { // your code that may block
      val recipes  =  DB.withSession { implicit s:Session => 
        Query(Recipes).list 
      } 
      Ok(recipes.mkString)
    } 
  }

Future期待 ExecutionContext (隐含的会做)；所有你需要传入 play-slick 使用的(隐式):

import play.api._
implicit val slickExecutionContext = 
  Akka.system.dispatchers.lookup("play.akka.actor.slick-context")