Dites que j'ai un Stream qui est plutôt cher à calculer. Je peux facilement créer un thread qui « calcule l'avance » juste en écrivant quelque chose commeQue se passe-t-il lorsqu'un Scala "Future" est collecté?
import scala.actors.Futures._
val s = future { stream.size }
Si je puis jeter la référence à ce Future, sera que le fil soit tué par le collecteur des ordures?
Non. Le thread appartient au planificateur. Dans tous les cas, le planificateur a une référence à l'avenir non terminé du corps (cela se produit dans a.start()), donc il ne sera pas collecté avant l'achèvement.
object Futures {
/** Arranges for the asynchronous execution of `body`,
* returning a future representing the result.
*
* @param body the computation to be carried out asynchronously
* @return the future representing the result of the
* computation
*/
def future[T](body: => T): Future[T] = {
val c = new Channel[T](Actor.self(DaemonScheduler))
val a = new FutureActor[T](_.set(body), c)
a.start()
a
}
}
Non. Le garbage collector ne tue jamais les fils. Le calcul peut avoir des effets secondaires que le garbage collector ne peut pas connaître, en d'autres termes, le thread peut faire quelque chose d'important que le garbage collector ne peut pas savoir - donc il ne peut jamais arrêter le thread en toute sécurité. – Jesper