Permettez-moi d'abord de dire que j'ai beaucoup d'expérience Java, mais que je ne me suis intéressé que récemment aux langages fonctionnels. Récemment, j'ai commencé à regarder Scala, qui semble être un très bon langage.
Cependant, j'ai lu sur le framework Actor de Scala dans Programming in Scala , et il y a une chose que je ne comprends pas. Au chapitre 30.4, il est dit que l'utilisation react
au lieu de receive
permet de réutiliser les threads, ce qui est bon pour les performances, puisque les threads sont chers dans la JVM.
Cela signifie-t-il que, tant que je me souviens d'appeler react
au lieu de receive
, je peux créer autant d'acteurs que je veux? Avant de découvrir Scala, j'ai joué avec Erlang, et l'auteur de Programming Erlang se vante de générer plus de 200 000 processus sans transpirer. Je détesterais faire ça avec les threads Java. Quel genre de limites est-ce que je regarde dans Scala par rapport à Erlang (et Java)?
En outre, comment cette réutilisation de thread fonctionne-t-elle dans Scala? Supposons, pour simplifier, que je n'ai qu'un seul fil. Tous les acteurs que je commence seront-ils exécutés séquentiellement dans ce fil, ou une sorte de changement de tâche aura-t-elle lieu? Par exemple, si je démarre deux acteurs qui se transmettent des messages ping-pong, est-ce que je risque une impasse s'ils sont démarrés dans le même thread?
Selon Programming in Scala , écrire des acteurs à utiliser react
est plus difficile qu'avec receive
. Cela semble plausible, car react
ne revient pas. Cependant, le livre continue en montrant comment vous pouvez mettre un react
dans une boucle en utilisant Actor.loop
. En conséquence, vous obtenez
loop {
react {
...
}
}
qui, pour moi, semble assez similaire à
while (true) {
receive {
...
}
}
qui est utilisé plus tôt dans le livre. Pourtant, le livre dit que "dans la pratique, les programmes auront besoin d'au moins quelques-uns receive
". Alors qu'est-ce que je manque ici? Que peut receive
faire qui ne react
peut pas, à part revenir? Et pourquoi je m'en soucie?
Enfin, revenons au cœur de ce que je ne comprends pas: le livre ne cesse de mentionner comment l'utilisation react
permet de supprimer la pile d'appels pour réutiliser le thread. Comment ça marche? Pourquoi est-il nécessaire de supprimer la pile d'appels? Et pourquoi la pile d'appels peut-elle être supprimée lorsqu'une fonction se termine en lançant une exception ( react
), mais pas lorsqu'elle se termine en retournant ( receive
)?
J'ai l'impression que Programming in Scala a passé sous silence certains des problèmes clés ici, ce qui est dommage, car sinon, c'est un livre vraiment excellent.