Пакет 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.

Этот класс предоставляет простую очередь FIFO объектов данных, которые считываются одним или несколькими потоками чтения.

DelayedLazyVal — это обёртка для длительных вычислений, имеющих валидный частично вычисленный результат.

Первый аргумент — функция получения результата в любой момент времени, а второй — длительное вычисление. После завершения вычисления метод apply перестанет перевычислять его и вернёт фиксированное значение с этого момента.

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

Универсальный ExecutionContext должен быть асинхронным при выполнении любого Runnable , переданного в метод 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 является лексическое ограничение выполнения кода. То есть каждый метод, класс, файл, пакет или приложение определяет, как выполнять свой собственный код. Это позволяет избежать проблем, таких как выполнение обратных вызовов приложения в пуле потоков, принадлежащем библиотеке для работы с сетью. Размеры пула потоков библиотеки для работы с сетью можно безопасно настроить, зная, что на них будут влиять только сетевые операции этой библиотеки. Выполнение обратных вызовов приложения можно настроить отдельно.

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

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

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

Маркер, указывающий, что java.lang.Runnable, предоставленный scala.concurrent.ExecutionContext, оборачивает обратный вызов, предоставленный Future.onComplete. Все обратные вызовы, предоставленные Future, в конечном итоге проходят через onComplete, поэтому это позволяет ExecutionContext специально обрабатывать обратные вызовы, которые были выполнены Future, если это необходимо.

SyncChannel позволяет синхронно обмениваться данными между потоком чтения и потоком записи. Поток записи блокируется до тех пор, пока данные, подлежащие записи, не будут прочитаны соответствующим потоком чтения.

Класс для обеспечения безопасного конкуретного доступа к изменяемой ячейке. Все методы синхронизированы.

Этот класс ...