Пакет scala.concurrent

Объект, который может быть в конечном итоге завершен значением типа T , которое может быть ожидаемо с помощью методов блокировки.

Объект Await предоставляет методы, которые позволяют получить результат Awaitable , блокируя текущий поток, пока Awaitable не будет завершен или не наступит таймаут.

Контекст, уведомляемый scala.concurrent.blocking , когда поток собирается заблокироваться. По сути, этот трайт предоставляет реализацию для scala.concurrent.Await. scala.concurrent.Await.result() и scala.concurrent.Await.ready() находят экземпляр BlockContext , сначала проверив, предоставлен ли он через BlockContext.withBlockContext(), а если нет, то проверяя, является ли Thread.currentThread экземпляром BlockContext. Таким образом, пул потоков может иметь свои экземпляры java.lang.Thread , реализующие BlockContext. Если поток не реализует BlockContext, используется по умолчанию BlockContext.

Как правило, вам следует продолжать цепочку с предыдущим BlockContext, как показано ниже:

val oldContext = BlockContext.current
val myContext = new BlockContext {
  override def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T = {
    // you'd have code here doing whatever you need to do
    // when the thread is about to block.
    // Then you'd chain to the previous context:
    oldContext.blockOn(thunk)
  }
}
BlockContext.withBlockContext(myContext) {
  // then this block runs with myContext as the handler
  // for scala.concurrent.blocking
}

Этот маркерный трайт используется объектом Await для обеспечения того, что Awaitable.ready и Awaitable.result не вызываются напрямую кодом пользователя. Неявный экземпляр этого трайта доступен только тогда, когда код пользователя в настоящее время вызывает методы объекта Await.

ExecutionContext может асинхронно выполнять логику программы, обычно, но не обязательно, в пуле потоков.

Объект общего назначения ExecutionContext должен быть асинхронным при выполнении любого действия, передаваемого в его метод execute. Специализированный ExecutionContext может быть синхронным, но должен передаваться только коду, который явно безопасен для выполнения с помощью синхронно выполняющего ExecutionContext.

API, такие как Future.onComplete , требуют от вас предоставления обратного вызова и неявного ExecutionContext. Неявный ExecutionContext будет использоваться для выполнения обратного вызова.

Хотя можно просто импортировать scala.concurrent.ExecutionContext.Implicits.global для получения неявного ExecutionContext, разработчики приложений должны внимательно подумать, где им необходимо установить политику выполнения; в идеале, в одном месте на приложение (или в связанном по логике разделе кода) принимается решение о выборе используемого ExecutionContext. То есть вы, как правило, хотите избегать жёсткого кодирования, особенно через импорт, scala.concurrent.ExecutionContext.Implicits.global. Рекомендуемый подход — добавить (implicit ec: ExecutionContext) к методам или параметрам конструктора класса, которым нужен ExecutionContext.

Затем локально импортируйте определенный ExecutionContext в одном месте для всего приложения или модуля, неявно передавая его в отдельные методы. В качестве альтернативы, определите локальную неявную переменную val с необходимым ExecutionContext.

Может быть уместен пользовательский ExecutionContext для выполнения кода, который блокируется на ввода-выводе или выполняет длительные вычисления. ExecutionContext.fromExecutorService и ExecutionContext.fromExecutor — хорошие способы создания пользовательского ExecutionContext.

Целью ExecutionContext является лексическое ограничение выполнения кода. То есть каждый метод, класс, файл, пакет или приложение определяет, как выполнять свой собственный код. Это предотвращает проблемы, такие как выполнение обратных вызовов приложения в пуле потоков, принадлежащем библиотеке сетевого взаимодействия. Размер пула потоков библиотеки сетевого взаимодействия можно безопасно настроить, зная, что затрагиваются только сетевые операции этой библиотеки. Выполнение обратных вызовов приложения можно настроить отдельно.

Future представляет собой значение, которое может или не может быть *в настоящее время* доступно, но будет доступно в какой-то момент, или исключение, если это значение не может быть сделано доступным.

Асинхронные вычисления, которые возвращают futures, создаются с помощью вызова Future.apply и вычисляются с использованием предоставленного ExecutionContext, который может быть основан на пуле потоков.

import ExecutionContext.Implicits.global
val s = "Hello"
val f: Future[String] = Future {
  s + " future!"
}
f foreach {
  msg => println(msg)
}

Promise — это объект, который может быть завершен значением или провален исключением.

Promise всегда должен быть в конечном итоге завершен, независимо от успеха или ошибки, чтобы избежать непреднамеренного удержания ресурсов для любых связанных функций обратного вызова или преобразований.