Possible de faire un obj/producteur/producteur dans Scala en utilisant des acteurs 'sans fil' (pas de réception ...)?

Question

Donc, je veux écrire un code réseau que apparaît pour bloquer, sans réellement bloquer un thread. Je vais envoyer des données sur le réseau, et avoir une «file d'attente» de réponses qui reviendront sur le réseau. J'ai écrit une très simple preuve de concept, inspiré par l'exemple producteur/consommateur sur le tutoriel acteur trouvé ici: http://www.scala-lang.org/node/242

La chose est, utilisez la réception semble prendre un fil, et je me demande si theres de toute façon de ne pas prendre un fil et encore obtenir le «sentiment de blocage». Heres mon exemple de code:

import scala.actors.Actor._; 
import scala.actors.Actor; 

case class Request(val s:String); 

case class Message(val s:String); 

class Connection { 
    private val act:Actor = actor { 
    loop { 
     react { 
     case m:Message => receive { case r:Request => reply { m } } 
     } 
    } 
} 

    def getNextResponse(): Message = { 
    return (act !? new Request("get")).asInstanceOf[Message]; 
    } 

    //this would call the network layer and send something over the wire 
    def doSomething() { 
    generateResponse(); 
    } 

    //this is simulating the network layer getting some data back 
    //and sending it to the appropriate Connection object 
    private def generateResponse() { 
    act ! new Message("someData"); 
    act ! new Message("moreData");  
    act ! new Message("even more data"); 
    } 

} 


object runner extends Application { 
val conn = new Connection(); 
    conn.doSomething(); 
    println(conn.getNextResponse()); 
    println(conn.getNextResponse()); 
    println(conn.getNextResponse()); 
} 

Est-il possible de le faire sans utiliser de réception, et ce qui rend Threadless?

Answer 1

Je m'attends à ce que vous puissiez utiliser réagir plutôt que de recevoir et de ne pas avoir des acteurs qui prennent des fils comme le fait la réception. Il y a un fil sur ce problème au receive vs react.

Answer 2

Vous pouvez directement compter sur react qui devrait bloquer et libération du fil:

class Connection { 
    private val act:Actor = actor { 
    loop { 
     react { 
     case r:Request => reply { r } 
     } 
    } 
    } 
[...] 

Answer 3

Ok, ce que je voulais faire exactement cela a été décrit ici: http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf