如何断开 Scala Remote Actor 的连接？

Question

在 scala 中，与远程参与者建立连接非常容易，但文档没有告诉我有关断开连接的任何信息。简单地丢弃引用是行不通的，因为远程参与者是参与者，所以在停止之前不会收集它们。那么我该如何断开连接呢？

退出后不会终止：

import actors.{DaemonActor,remote}
import remote.{RemoteActor,Node}

object SimpleClient{
    val messageHandler = new DaemonActor{
        def act{
            loop{
                react{
                    case message:String =>
                        println("got message: " + message)
                    case _ =>
                }
            }
        }
        start
    }

    def main(args:Array[String]){
        val server = RemoteActor.select(Node("localhost",9999),'server)
        server.send('Connect,messageHandler)

        var exit = false
        while(!exit){
            val message = Console.readLine
            if(message == "exit" || message == "quit") {
                exit = true
                server ! 'Disconnect
            }
            else
                server ! message
        }
    }
}

这是服务器：

import actors.{Actor,OutputChannel}
import actors.remote.RemoteActor

object Server extends Actor{
    val clients = new collection.mutable.HashSet[OutputChannel[Any]]
    def act{
        loop{
            react{
                case 'Connect =>
                    clients += sender
                case 'Disconnect =>
                    clients -= sender
                case message:String =>
                    for(client <- clients)
                        client ! message
            }
        }
    }

    def main(args:Array[String]){
        start
        RemoteActor.alive(9999)
        RemoteActor.register('server,this)
    }
}

Answer 1

[免责声明：我是 Akka 的 PO]

我可以建议看一下 Akka，它从第一天起就考虑到了远程 Actor 的构建方式吗？
akka.io

Answer 2

您的问题对于您认为遇到的问题还不够清楚。 Actor不相互“连接”（就像套接字一样）。您向参与者发送消息是因为您拥有对它的引用（或者在远程参与者的情况下是代理）。

拥有这样的引用并不能阻止参与者（任一参与者）关闭。如果不再有任何对 Actor 的引用并且它没有运行，则没有什么可以阻止它被垃圾收集

Answer 3

Reactor 特征定义了 protected[actors] def exit(): Nothing，actor 在收到通知它这样做的消息后可以调用自己。

sealed trait Msg
case object Apoptosis extends Msg
// ... more messages


class RRActor extends Reactor[Msg] {
  def act =  loop {
    react {
      // ... Whatever messages the actor handles
      case Apoptosis => this.exit
    }
  }
}

编辑：我还没有对远程演员进行过测试。

Answer 4

这是源代码的工作版本，并内嵌注释了相关更改：

import actors.{DaemonActor,remote}
import remote.{RemoteActor,Node}

case class Send(message: String)
case object Disconnect

object SimpleClient{
    val messageHandler = new DaemonActor{

       def act{
          // keep the reference to the proxy inside the client-side actor
          val server = RemoteActor.select(Node("localhost",9999),'server)
          server ! 'Connect
          loop{
             react{
                case message:String =>
                   println("got message: " + message)
                case Send(message) => server ! message
                case Disconnect => { 
                   // disconnect and exit the client-side actor
                   server ! 'Disconnect //'
                   exit
                }
                case _ =>
              }
          }
      }
      start
   }

   def main(args:Array[String]){
      var exit = false
      while(!exit){
         val message = Console.readLine
         if(message == "exit" || message == "quit") {
            exit = true
            // tell the client-side actor to exit
            messageHandler ! Disconnect
         } else {
            messageHandler ! Send(message)
         }
      }
   }
}