Make ApplicationProvider.get asynchronous

[richdougherty]

There have been a number of issues caused by the blocking nature of ApplicationProvider.get: #5975, #7614, #7622. Threads get starved because every thread can end up blocking while reloading. Only one thread really needs to block—the reloading one—and the others could just wait for the result in a Future[Application].

I'm not implementing the change yet because we're still backporting stuff to 2.6 and this seems a bit too heavy to backport. However, here's a sketch solution so it's easy to implement later:

trait ApplicationProvider {
  @deprecated
  def get: Try[Application]
  def getAsync(): Future[Application]
}

class DevServerStart {
  val appProvider = new ApplicationProvider {
    // Used for atomic locking
    private val reloadAtomic = new AtomicReference[Option[Future[Application]]](None)
    def getAsync(): Future[Application] = {
      // Use an atomic lock to restrict access so only one
      // thread reloads the application at a time.
      @tailrec def atomicLoop(): Future[Application] = {
        val atomicRead = reloadAtomic.get()
        atomicRead match {
          case Some(future) => future
          case None =>
            val promise = Promise[Future[Application]]
            val atomicWrite = Some(promise.future)
            if (currentReload.compareAndSet(None, myFuture)) {
              val reloadFuture = getAsyncExclusively()
              promise.completeWith(reloadFuture)
            } else {
              loop()
            }
        }
      }
      atomicLoop()
    }
    def get(): Try[Application] {
      val readyFuture = Await.ready(getAsync(), Duration.Inf)
      readyFuture.value.get
    }
    private def getAsyncExclusively(): Future[Application] = {
      ... buildLink.reload, etc ...
    }
  }
}

[viktorklang]

@richdougherty

You could consider something like this to keep object creation and indirection down a bit:

// Used for atomic locking
    private val reloadAtomic = new AtomicReference[Promise[Application]](null)
    def getAsync(): Future[Application] = {
      // Use an atomic lock to restrict access so only one
      // thread reloads the application at a time.
      @tailrec def atomicLoop(p: Promise[Application]): Future[Application] = reloadAtomic.get() match {
        case null =>
          val mkPromise = if (p eq null) Promise[Future[Application]] else p
          if (reloadAtomic.compareandSet(null, mkPromise))
            mkPromise.completeWith(getAsyncExclusively()).future
          else atomicLoop(mkPromise)
        case some => some.future
      }
     atomicLoop(null)
  }

[richdougherty]

OK thanks. :)

And how did you even notice this ticket, do you have an email filter scanning for the word AtomicReference? 😉

[viktorklang]

@richdougherty The Klang sees everything.

[richdougherty]

For those who don't know about ApplicationProvider.get, this issue only affects dev mode. It won't happen in production.

[He-Pin]

@viktorklang The Klang love @tailrec and AtomicReference[_].