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

声明:本文是《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同样支持远程角色,以便使我们可以在不同机器的离散进程之间发送消息。

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

方 腾飞

花名清英,并发网(ifeve.com)创始人,畅销书《Java并发编程的艺术》作者,蚂蚁金服技术专家。目前工作于支付宝微贷事业部,关注互联网金融,并发编程和敏捷实践。微信公众号aliqinying。
FavoriteLoading添加本文到我的收藏
  • Trackback 关闭
  • 评论 (0)
  1. 暂无评论

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

return top