Default maxConnections == numThreads

See discussion in #1614 about deadlocks caused by maxConnections > numThreads.

slick-hikaricp/src/main/scala/slick/jdbc/hikaricp/HikariCPJdbcDataSource.scala

@@ -45,7 +45,7 @@ object HikariCPJdbcDataSource extends JdbcDataSourceFactory {
    c.getStringOpt("connectionTestQuery").foreach(hconf.setConnectionTestQuery)
    c.getStringOpt("connectionInitSql").foreach(hconf.setConnectionInitSql)
    val numThreads = c.getIntOr("numThreads", 20)
    hconf.setMaximumPoolSize(c.getIntOr("maxConnections", numThreads * 5))
    hconf.setMaximumPoolSize(c.getIntOr("maxConnections", numThreads))
    hconf.setMinimumIdle(c.getIntOr("minConnections", numThreads))
    hconf.setPoolName(c.getStringOr("poolName", name))
    hconf.setRegisterMbeans(c.getBooleanOr("registerMbeans", false))

slick-testkit/src/test/scala/slick/test/jdbc/DataSourceTest.scala

@@ -35,7 +35,7 @@ class DataSourceTest {
    MockDriver.reset
    val db = JdbcBackend.Database.forConfig("databaseUrl")
    try {
      assertEquals(Some(100), db.source.maxConnections)
      assertEquals(Some(20), db.source.maxConnections)
      try Await.result(db.run(sqlu"dummy"), Duration.Inf) catch { case ex: SQLException => }
      val (url, info) = MockDriver.getLast.getOrElse(fail("No connection data recorded").asInstanceOf[Nothing])
      assertEquals("jdbc:postgresql://host/dbname", url)
@@ -50,7 +50,7 @@ class DataSourceTest {
    MockDriver.reset
    val db = JdbcBackend.Database.forConfig("databaseUrlNoPassword")
    try {
      assertEquals(Some(100), db.source.maxConnections)
      assertEquals(Some(20), db.source.maxConnections)
      try Await.result(db.run(sqlu"dummy"), Duration.Inf) catch { case ex: SQLException => }
      val (url, info) = MockDriver.getLast.getOrElse(fail("No connection data recorded").asInstanceOf[Nothing])
      assertEquals("jdbc:postgresql://host/dbname", url)
@@ -65,7 +65,7 @@ class DataSourceTest {
    MockDriver.reset
    val db = JdbcBackend.Database.forConfig("databaseUrlMySQL")
    try {
      assertEquals(Some(100), db.source.maxConnections)
      assertEquals(Some(20), db.source.maxConnections)
      try Await.result(db.run(sqlu"dummy"), Duration.Inf) catch { case ex: SQLException => }
      val (url, info) = MockDriver.getLast.getOrElse(fail("No connection data recorded").asInstanceOf[Nothing])
      assertEquals("jdbc:mysql://host/dbname?useUnicode=yes&characterEncoding=UTF-8&connectionCollation=utf8_general_ci", url)
@@ -80,7 +80,7 @@ class DataSourceTest {
    MockDriver.reset
    val db = JdbcBackend.Database.forConfig("databaseUrlMySQLNoPassword")
    try {
      assertEquals(Some(100), db.source.maxConnections)
      assertEquals(Some(20), db.source.maxConnections)
      try Await.result(db.run(sqlu"dummy"), Duration.Inf) catch { case ex: SQLException => }
      val (url, info) = MockDriver.getLast.getOrElse(fail("No connection data recorded").asInstanceOf[Nothing])
      assertEquals("jdbc:mysql://host/dbname?useUnicode=yes&characterEncoding=UTF-8&connectionCollation=utf8_general_ci", url)
@@ -95,7 +95,7 @@ class DataSourceTest {
    MockDriver.reset
    val db = JdbcBackend.Database.forConfig("altDatabaseUrl")
    try {
      assertEquals(Some(100), db.source.maxConnections)
      assertEquals(Some(20), db.source.maxConnections)
      try Await.result(db.run(sqlu"dummy"), Duration.Inf) catch { case ex: SQLException => }
      val (url, info) = MockDriver.getLast.getOrElse(fail("No connection data recorded").asInstanceOf[Nothing])
      assertEquals("jdbc:postgresql://host/dbname", url)
@@ -132,7 +132,7 @@ class DataSourceTest {
        |""".stripMargin
    ))
    try {
      assertEquals("maxConnections should be numThreads * 5", Some(50), db.source.maxConnections)
      assertEquals("maxConnections should be numThreads", Some(10), db.source.maxConnections)
    } finally db.close
  }

slick-testkit/src/test/scala/slick/test/jdbc/MBeansTest.scala

@@ -39,7 +39,7 @@ class MBeansTest {
      Await.result(db.run(sqlu"""create alias sleep for "java.lang.Thread.sleep""""), Duration(10, TimeUnit.SECONDS))

      assertEquals(1, mbeanServer.getAttribute(aeBeanName, "MaxThreads"))
      mbeanServer.getAttribute(aeBeanName, "ActiveThreads") // we expect 0 but the returned number is only an estimate
      mbeanServer.getAttribute(aeBeanName, "ActiveThreads") // we expect 1, since minThreads == maxThreads
      assertEquals(1000, mbeanServer.getAttribute(aeBeanName, "MaxQueueSize"))
      assertEquals(0, mbeanServer.getAttribute(aeBeanName, "QueueSize"))

slick-testkit/src/test/scala/slick/test/jdbc/hikaricp/SlickDeadlockTest.scala

@@ -47,23 +47,23 @@ class SlickDeadlockTest extends AsyncTest[JdbcTestDB] {

  @Test def slickDoesNotDeadlock() {

    val tasks = 1 to 100 map { i =>
    val tasks = 1 to 51 map { i =>
      val action = { testTable += i }
        .flatMap { _ => testTable.length.result }
        .flatMap { _ => DBIO.successful(s"inserted value $i") }

      database.run(action.transactionally)
    }
    Await.result(Future.sequence(tasks), Duration(10, TimeUnit.SECONDS))
    Await.result(Future.sequence(tasks), Duration(100, TimeUnit.SECONDS))
  }

  @Test def slickDoesNotDeadlockWithSleeps(): Unit = {
    val tasks = 1 to 50 map { c =>
    val tasks = 1 to 21 map { c =>
      val action = sql"select $c".as[Int].head.map { i => Thread.sleep(if(c == 1) 100 else 200); i }

      database.run(action.transactionally)
    }
    Await.result(Future.sequence(tasks), Duration(10, TimeUnit.SECONDS))
    Await.result(Future.sequence(tasks), Duration(100, TimeUnit.SECONDS))

  }

@@ -73,14 +73,14 @@ class SlickDeadlockTest extends AsyncTest[JdbcTestDB] {
        (blobTable += (1, new SerialBlob(Array[Byte](1,2,3)))) >>
        (blobTable += (2, new SerialBlob(Array[Byte](4,5)))) >>
        blobTable.result
    ).transactionally), Duration(2, TimeUnit.SECONDS))
    ).transactionally), Duration(20, TimeUnit.SECONDS))

    val tasks = 1 to 100 map { i =>
    val tasks = 1 to 51 map { i =>
      materializeAsync[(Int, Blob), (Int, String)](database.stream(blobTable.result.transactionally, bufferNext = false),
        { case (id, data) => database.io((id, data.getBytes(1, data.length.toInt).mkString)) })
    }

    Await.result(Future.sequence(tasks), Duration(10, TimeUnit.SECONDS))
    Await.result(Future.sequence(tasks), Duration(100, TimeUnit.SECONDS))
  }

}

slick/src/main/scala/slick/jdbc/JdbcBackend.scala

@@ -186,7 +186,7 @@ trait JdbcBackend extends RelationalBackend {
      *     the JDBC driver. This is preferred over using `driver`. Note that `url` is ignored when
      *     this key is set (You have to use `properties` to configure the database
      *     connection instead).</li>
      *   <li>`maxConnections` (Int, optional, default: `numThreads` * 5): The maximum number of
      *   <li>`maxConnections` (Int, optional, default: `numThreads`): The maximum number of
      *     connections in the pool.</li>
      *   <li>`minConnections` (Int, optional, default: same as `numThreads`): The minimum number
      *     of connections to keep in the pool.</li>
@@ -287,7 +287,7 @@ trait JdbcBackend extends RelationalBackend {
      val source = JdbcDataSource.forConfig(usedConfig, driver, path, classLoader)
      val poolName = usedConfig.getStringOr("poolName", path)
      val numThreads = usedConfig.getIntOr("numThreads", 20)
      val maxConnections = source.maxConnections.fold(numThreads*5)(identity)
      val maxConnections = source.maxConnections.fold(numThreads)(identity)
      val registerMbeans = usedConfig.getBooleanOr("registerMbeans", false)
      val executor = AsyncExecutor(poolName, numThreads, numThreads, usedConfig.getIntOr("queueSize", 1000),
        maxConnections, registerMbeans = registerMbeans)