Fix #1614, Fix #1807: require and warn about bad configurations that …

…can result in deadlocks

slick/src/main/scala/slick/util/AsyncExecutor.scala

@@ -56,19 +56,61 @@ object AsyncExecutor extends Logging {
 
     @volatile private[this] var executor: ThreadPoolExecutor = _
 
+    if (maxConnections > maxThreads) {
+      // NOTE: when using transactions or DB locks, it may happen that a task has a lock on the database but no thread
+      // to complete its action, while other tasks may have all the threads but are waiting for the first task to
+      // complete. This creates a deadlock.
+      logger.warn("Having maxConnection > maxThreads can result in deadlocks if transactions or database locks are used.")
+    }
+
     lazy val executionContext = {
       if(!state.compareAndSet(0, 1))
         throw new IllegalStateException("Cannot initialize ExecutionContext; AsyncExecutor already shut down")
       val queue: BlockingQueue[Runnable] = queueSize match {
-        case 0 => new SynchronousQueue[Runnable]
-        case -1 => new LinkedBlockingQueue[Runnable]
-        case n => new ManagedArrayBlockingQueue(maxConnections, n).asInstanceOf[BlockingQueue[Runnable]]
+        case 0 =>
+          // NOTE: SynchronousQueue does not schedule high-priority tasks before others and so it cannot be used when
+          // the number of connections is limited (lest high-priority tasks may be holding all connections and low/mid
+          // priority tasks all threads -- resulting in a deadlock).
+          require(maxConnections == Integer.MAX_VALUE, "When using queueSize == 0 (direct hand-off), maxConnections must be Integer.MAX_VALUE.")
+
+          new SynchronousQueue[Runnable]
+        case -1 =>
+          // NOTE: LinkedBlockingQueue does not schedule high-priority tasks before others and so it cannot be used when
+          // the number of connections is limited (lest high-priority tasks may be holding all connections and low/mid
+          // priority tasks all threads -- resulting in a deadlock).
+          require(maxConnections == Integer.MAX_VALUE, "When using queueSize == -1 (unlimited), maxConnections must be Integer.MAX_VALUE.")
+
+          new LinkedBlockingQueue[Runnable]
+        case n =>
+          // NOTE: The current implementation of ManagedArrayBlockingQueue is flawned. It makes the assumption that all
+          // tasks go through the queue (which is responsible for scheduling high-priority tasks first). However, that
+          // assumption is wrong since the ThreadPoolExecutor bypasses the queue when it creates new threads. This
+          // happens when ever it creates a new thread to run a task, i.e. when minThreads < maxThreads and the number
+          // of existing threads is < maxThreads.
+          //
+          // The only way to prevent problems is to have minThreads == maxThreads when using the
+          // ManagedArrayBlockingQueue.
+          require(minThreads == maxThreads, "When using queueSize > 0, minThreads == maxThreads is required.")
+
+          // NOTE: The current implementation of ManagedArrayBlockingQueue.increaseInUseCount implicitly `require`s that
+          // maxThreads <= maxConnections.
+          require(maxThreads <= maxConnections, "When using queueSize > 0, maxThreads <= maxConnections is required.")
+
+          // NOTE: Adding up the above rules
+          // - maxThreads >= maxConnections, to prevent database locking issues when using transactions
+          // - maxThreads <= maxConnections, required by ManagedArrayBlockingQueue
+          // - maxThreads == minThreads, ManagedArrayBlockingQueue
+          //
+          // We have maxThreads == minThreads == maxConnections as the only working configuration
+
+          new ManagedArrayBlockingQueue(maxConnections, n).asInstanceOf[BlockingQueue[Runnable]]
       }
       val tf = new DaemonThreadFactory(name + "-")
       executor = new ThreadPoolExecutor(minThreads, maxThreads, keepAliveTime.toMillis, TimeUnit.MILLISECONDS, queue, tf) {
 
         /** If the runnable/task is a low/medium priority item, we increase the items in use count, because first thing it will do
-          * is open a Jdbc connection from the pool. */
+          * is open a Jdbc connection from the pool.
+          */
         override def beforeExecute(t: Thread, r: Runnable): Unit = {
           (r, queue) match {
             case (pr: PrioritizedRunnable, q: ManagedArrayBlockingQueue[Runnable]) if pr.priority != WithConnection => q.increaseInUseCount(pr)