Futures do blokowania połączeń w Scala

Question

Akka dokumentacja mówi:

możesz ulec pokusie, aby po prostu zawinąć blokowania połączeń wewnątrz przyszłość i pracować z tym, że zamiast, ale ta strategia jest zbyt prosta: jesteś całkiem prawdopodobne znajdowanie wąskich gardeł lub brak pamięci lub wątków, gdy aplikacja działa pod zwiększonym obciążeniem.

Sugerują one następujące strategie:

• Czy połączenie blokujące obrębie Future, zapewniając górną granicę liczby takich połączeń w dowolnym momencie (składając liczbę nieograniczony zadań niniejszego natura wyczerpuje twoją pamięć lub granice wątków).

• Wykonaj wywołanie blokowania w ramach Future, udostępniając pulę wątków z górnym limitem liczby wątków, która jest odpowiednia dla sprzętu, na którym działa aplikacja.

Czy znasz jakieś wdrożenie tych strategii?

Answer 1

Kontrakty terminowe są realizowane w ramach execution contexts. Jest to oczywiste z interfejsu API Future: każde wywołanie, które wiąże się z dołączaniem niektórych wywołań zwrotnych do przyszłości lub budowaniem przyszłości z dowolnego obliczenia lub z innej przyszłości, wymaga niejawnie dostępnego obiektu o wartości ExecutionContext. Możesz więc kontrolować konfigurację współbieżności dla swojej przyszłości przez dostrojenie ExecutionContext, w której działają.

Na przykład, w celu wdrożenia drugiego strategię można zrobić coś jak

import scala.concurrent.ExecutionContext 
import java.util.concurrent.Executors 
import scala.concurrent.future 

object Main extends App { 

    val ThreadCount = 10 
    implicit val executionContext = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(ThreadCount)) 

    val f = future { 
    println(s"Hello ! I'm running in an execution context with $ThreadCount threads") 
    } 

} 

Answer 2

sama Akka realizuje to wszystko, można owinąć blokujące połączenia w Podmiotów, a następnie użyć dispatchers kontrolować wykonywanie basenów wątku.