Qual è un buon modo per creare metodi non bloccanti in Scala? Un modo in cui posso pensare è creare un thread/attore e il metodo semplicemente invia un messaggio al thread e restituisce. C'è un modo migliore per creare un metodo non bloccante?Come creare metodi non bloccanti in Scala?
Uso scala.actors.Future:
import actors._
def asyncify[A, B](f: A => B): A => Future[B] = (a => Futures.future(f(a)))
// normally blocks when called
def sleepFor(seconds: Int) = {
Thread.sleep(seconds * 1000)
seconds
}
val asyncSleepFor = asyncify(sleepFor)
val future = asyncSleepFor(5) // now it does NOT block
println("waiting...") // prints "waiting..." rightaway
println("future returns %d".format(future())) // prints "future returns 5" after 5 seconds
sovraccaricato "asyncify" che prende una funzione con più di un parametro viene lasciato come esercizio.
Un avvertimento, tuttavia, è la gestione delle eccezioni. La funzione che è "asincrona" deve gestire tutte le eccezioni stesse catturandole. Il comportamento per le eccezioni espulse dalla funzione non è definito.
Informazioni sui actors.
Dipende dalla definizione di "blocco". A rigor di termini, tutto ciò che richiede l'acquisizione di un blocco sta bloccando. Tutte le operazioni che dipendono dallo stato interno di un attore acquisiscono un blocco sull'attore. Questo include le mandate dei messaggi. Se molti thread tentano di inviare un messaggio a un attore tutto insieme, devono mettersi in fila.
Quindi, se davvero hai bisogno di non bloccare, ci sono varie opzioni in java.util.concurrent.
Detto questo, da un pratico attori prospettiva ti danno qualcosa che abbastanza vicino per non bloccante perché nessuna delle operazioni sincronizzate fare una notevole quantità di lavoro, quindi è probabile che gli attori soddisfare il vostro bisogno.
Ho una spiegazione molto approfondita sul mio blog sui futures. In realtà ti mostra come potresti implementare il futuro da solo, e quindi ti dà un'ottima comprensione dell'argomento. Io suggerisco di leggere che:
Portate il vostro caffè!