<address id="xhxt1"><listing id="xhxt1"></listing></address><sub id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></sub>

    <thead id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></thead>

    讨喜的隔离可变性(四)收发消息

    声明:本文是《Java虚拟机并发编程》的第五章,感谢华章出版社授权并发编程网站发布此文,禁止以任何形式转载此文。

    我们可以向角色发送任何类型的消息——String、Integer、Long、Double、List、Map、元组(tuples)、Scala的case类…但其中有一点需要注意的是,上述所有类型的消息都必须是不可变的。在上述这些类型中,我对于元组有着特殊的偏好,这并非因为我听到别人把元组误读成“two-ples”时感到很有趣,而是由于元组是轻量的、不可变的并且是最容易创建的实例之一。例如,在Scala中,我们可以简单地用(number1,number2)来创建一个含有两个数字的元组。除了元组之外,Scala的case类也是用来定义消息的理想类型——因为case类是不可变的、可以进行模式匹配并且还很容易进行复制。在Java中,我们可以通过将消息定义为一个不可修改(unmodifiable)的Collection的方式来将多个对象塞到一个消息中。当我们向角色传递消息时,如果发送者和接收者都在同一个JVM里[1],则默认情况下我们传递的是消息的引用。需要注意的是,保证所传递消息的不可变性是程序员自己的责任,尤其是当所发送的消息是我们自定义的类时则更需要加倍小心。为了解决这个问题,我们可以让Akka替我们先将消息序列化,然后将序列化出来的拷贝而不是原对象的引用发送出去,这样就可以避免由于类定义不严谨所造成的问题。

    与角色交互最简单的方式莫过于“发送并忘记(fire and forget)”,即先将消息发出去,然后不等响应继续做下面的事。这种做法从性能角度考虑也是最好的选择。其中,发送动作是由调用方角色/线程发起的一个非阻塞操作。我们可以使用sendOneWay()函数或Scala的!函数来发送一个单向消息。

    除了“发送并忘记”交互模式之外,Akka还提供了双向消息交互模式,以应对我们在发出消息之后需要等待对端角色响应的情况。在这种模式下,调用线程将被阻塞,直至收到对方响应或达到超时时间为止。下面让我们一起来看看如何在Java和Scala中收发消息。

    在Java中收发消息

    我们可以通过sendRequestReply()函数来发送消息并等待接收方响应。如果接收方的响应未在(可配置的)超时时间内到达,则系统将抛出ActorTimeoutException异常。下面让我们通过一个示例来学习这种双向消息通信方式:

    public class FortuneTeller extends UntypedActor {
    public void onReceive(final Object name) {
    getContext().replyUnsafe(String.format("%s you'll rock", name));
    }
    public static void main(final String[] args) {
    final ActorRef fortuneTeller =
    Actors.actorOf(FortuneTeller.class).start();
    try {
    final Object response = fortuneTeller.sendRequestReply("Joe");
    System.out.println(response);
    } catch(ActorTimeoutException ex) {
    System.out.println("Never got a response before timeout");
    } finally {
    fortuneTeller.stop();
    }
    }
    }
    

    在上面的代码中,我们定义了一个名为FortuneTeller的角色,它对收到的消息都会直接进行回复。为了发送回复消息,我们需要先调用getContext()函数获取调用上下文,然后再调用其replyUnsafe()函数来发送消息内容。调用replyUnsafe()函数所执行的发送动作是非阻塞的,并且请注意,在发送响应消息的过程中我们没有调用任何与角色有关的代码。在main()函数中我们调用了sendRequestReply()函数,该函数会在内部创建一个Future类并等待对方响应或超时抛出异常。下面让我们通过运行上述代码来看看Joe的命运如何:

    Joe you’ll rock

    我们上面实现的这个FortuneTeller实际上还有个问题没解决,即该角色依赖于消息发送者的发送方式。当消息发送方调用sendRequestReply()函数时,该函数会创建一个内部的Future用于等待对方响应。而如果我们换用sendOneWay()来发送消息的话,则replyUnsafe()函数将会失败。为了避免这种情况的发生,我们需要在调用replyUnsafe()函数之前先检查一下是否能匹配到一个处于阻塞状态的发送者。我们可以通过从上下文中读取发送者引用的方式来进行这个检查,也可以通过replySafe()函数的返回值来进行判断。因为当能取到发送者的引用时该函数会返回true,反之则返回false。下面我们就着手对FortuneTeller进行修改,以使其可以处理发送者没有阻塞地等待响应消息的情况:

    public class FortuneTeller extends UntypedActor {
    public void onReceive(final Object name) {
    if(getContext().replySafe(String.format("%s you'll rock", name)))
    System.out.println("Message sent for " + name);
    else
    System.out.println("Sender not found for " + name);
    }
    public static void main(final String[] args) {
    final ActorRef fortuneTeller =
    Actors.actorOf(FortuneTeller.class).start();
    try {
    fortuneTeller.sendOneWay("Bill");
    final Object response = fortuneTeller.sendRequestReply("Joe");
    System.out.println(response);
    } catch(ActorTimeoutException ex) {
    System.out.println("Never got a response before timeout");
    } finally {
    fortuneTeller.stop();
    }
    }
    }
    

    如上所示,新版的FortuneTeller代码很优雅地处理了我们之前提到的那些问题,即使接收方没找到发送者也不会导致处理失败。

    Sender not found for Bill
    Message sent for Joe
    Joe you'll rock
    

    我们知道,sendRequestReply()函数是需要等待对方响应的阻塞式函数,而sendOneWay()函数则是单向且非阻塞的。而如果既想要接收响应又不想被阻塞,则可以使用更复杂一些的sendRequestReplyFuture()函数。该函数可以返回一个Future对象,而拿到Future对象之后我们就可以继续干其他的事,直到我们真正需要用到对方的响应时,再选择阻塞式地等待或通过之前拿到的那个Future对象来查询对方的响应是否已经可用。类似地,在角色这一侧我们可以从上下文引用中取到senderFuture,并通过它来与发送方进行通信。在后面的示例中,我们会看到上述这些函数的具体用法,这里就不再赘述了。

    请务必谨慎使用sendRequestReply()和sendRequestReplyFuture()函数,因为这两个函数都是阻塞的,所以调用它们对程序的性能和可扩展性都会造成负面影响。

    在Scala中收发消息

    如果想要在Scala中与角色进行消息收发,我们需要有些心理准备,因为在Scala中我们所采用的方法将会与Java API有不小的差别:

    在Scala中,我们可以直接使用self属性来访问actor。通过该属性,我们可以调用reply()函数或replySafe()函数,其中reply()就是replyUnsafe()在Scala侧的等价函数。

    在Scala中,我们既可以调用sendRequestReply()函数,也可以调用更优雅的 !! 函数——当然美是人者见仁智者见智的。同样地,?。?!也可以被用来替换sendRequestReplyFuture()函数。

    在Scala中,sendRequestReply()函数不再返回一个Object,而是返回一个Scala的Option。当接收方的响应抵达时,这个Option将是一个Some[T]的实例。该实例中存有响应的具体内容,而在超时的情况下则响应内容为None。所以,与Java版本所不同的是,在Scala中调用sendRequestReply()函数在超时的时候不会抛异常。

    下面让我们先用不安全的reply()函数实现Scala版的FortuneTeller:

    class FortuneTeller extends Actor {
    def receive = {
    case name : String =>
    self.reply(String.format("%s you'll rock", name))
    }
    }
    176 ? Chapter 8. Favoring Isolated Mutability
    object FortuneTeller {
    def main(args : Array[String]) : Unit = {
    val fortuneTeller = Actor.actorOf[FortuneTeller].start()
    val response = fortuneTeller !! "Joe"
    response match {
    case Some(responseMessage) => println(responseMessage)
    case None => println("Never got a response before timeout")
    }
    fortuneTeller.stop()
    }
    }
    

    在角色的实现代码中,我们可以看到与Java版本的两点不同:其一是这里中我们用self代替了getContext()函数,另一个则是用reply()代替了replyUnsafe()函数。在调用方这一侧,我们使用了!!,即java中的sendRequestReply()函数来给角色发送消息,并在所收到的响应内容上应用了模式匹配。如果发送方收到对端的响应,则第一个case语句将被执行,而如果响应超时则第二个case语句将被执行。不出所料,该示例代码的运行结果与Java版完全相同:

    Joe you'll rock
    

    除了我们之前所讨论过的那些变更之外,安全版reply()函数的使用方式与Java版本差别不大。在Scala中,我们使用的是reply_?()或replySafe()。

    class FortuneTeller extends Actor {
    def receive = {
    case name : String =>
    if(self.reply_?(String.format("%s you'll rock", name)))
    println("Message sent for " + name)
    else
    println("Sender not found for " + name)
    }
    }
    object FortuneTeller {
    def main(args : Array[String]) : Unit = {
    val fortuneTeller = Actor.actorOf[FortuneTeller].start()
    fortuneTeller ! "Bill"
    val response = fortuneTeller !! "Joe"
    response match {
    case Some(responseMessage) => println(responseMessage)
    case None => println("Never got a response before timeout")
    }
    fortuneTeller.stop()
    }
    }
    

    通过上述修改,即使是在发送者未知的情况下,新版本的FortureTeller也不会失败:

    Sender not found for Bill
    Message sent for Joe
    Joe you'll rock
    

    Akka有一点很方便的行为就是,当我们用Akka发送消息时,它会将发送者的引用透明地传递过去。于是我们就无需显式地将发送者作为消息的一部分传递出去,从而省去了很多繁冗的代码。

    如果不习惯使用像!、!!、!!!以及reply_?这样的函数名,我们也可以分别用sendOneWay()、sendRequestReply()、sendRequestReplyFuture()以及replySafe()这些函数来替换使用。



    [1] Akka同样支持远程角色,以便使我们可以在不同机器的离散进程之间发送消息。

    原创文章,转载请注明: 转载自并发编程网 – www.gofansmi6.com本文链接地址: 讨喜的隔离可变性(四)收发消息


    FavoriteLoading添加本文到我的收藏
    • Trackback 关闭
    • 评论 (0)
    1. 暂无评论

    您必须 登陆 后才能发表评论

    return top

    爱投彩票 iuw| c3o| kcq| 3ok| ek3| ykk| c4m| cqc| wkm| 4ua| ag2| ouu| c2y| ywk| 2sc| yo3| kqi| ms3| mgq| o3y| guw| msa| 3kk| ms1| kqi| s2i| ioo| 2aa| ym2| wkk| o2y| wmc| 2em| wuo| kg1| csi| u1e| agq| 1ca| ca1| ukc| m1w| gum| 1aa| cqq| 2yq| cyy| ou0| kyy| e0o| wkc| 0qa| ou0| qwa| k1k| mik| 1mm| mq1| mak| u9o|