本文介绍了Akka框架中Actor之间的通信方式，重点讲解了tell()方法的使用，包括消息发送者和接收者的判断，以及消息的异步处理。同时，讨论了ask()方法在需要等待响应的情况下的应用，以及Future对象在处理异步结果中的角色。
ps:要搞清楚谁是消息的发送者和接收者
目录
2.使用Actor调用tell()方法，如何判断谁是消息的发送者和接收者
1.tell()
在Akka中，Actor之间通过发送消息来进行通信。tell()方法是Actor中最常用的发送消息的方法之一。在本文中，我们将详细介绍tell()方法的使用方法以及其内部实现。tell()方法的定义如下：
void tell(Object message, ActorRef sender);
其中，message参数表示要发送的消息，sender参数表示消息的发送者。
在使用tell()方法时，我们需要先获取目标Actor的引用。有两种方法可以获取目标Actor的引用：
1.使用ActorContext.actorSelection()方法获取Actor的引用。该方法返回一个ActorSelection对象，表示一组Actor的选择器。可以使用选择器定位到具体的Actor，然后通过ActorSelection.tell()方法向Actor发送消息。
ActorSelection selection = getContext().actorSelection("akka://MyActorSystem/user/targetActor");
selection.tell(message, getSelf());
2.直接使用ActorRef对象向Actor发送消息。
targetActor.tell(message, getSelf());
在使用tell()方法时，通常我们会将发送者Actor的引用作为sender参数传递。这样，在接收到消息的Actor中，可以通过sender()方法获取消息的发送者。
@Override
public Receive createReceive() {
return receiveBuilder()
.match(Message.class, message -> {
ActorRef sender = getSender();
// 处理消息
})
.build();
}
在Akka中，所有的消息都是异步发送的。当我们使用tell()方法向Actor发送消息时，消息会被封装为一个Envelope对象，然后被放入Actor的消息队列中等待处理。当消息被处理时，会从队列中取出Envelope对象并解包，然后调用Actor的receive()方法进行处理。
在调用tell()方法时，发送者Actor和目标Actor之间的消息通信是通过ActorRef对象进行的。ActorRef是一个轻量级的、线程安全的、可序列化的引用，它可以被用于在Actor之间传递消息。ActorRef的实现方式是基于异步消息传递的，它的主要作用是将消息传递给目标Actor，并保证消息的可靠传递。因此，ActorRef是Akka框架中非常重要的组件。
在实际使用中，由于Actor的消息队列是无界的，因此如果消息的发送速度大于接收速度，就可能会导致队列积压。为了避免这种情况，我们可以使用Actor的异步回复机制，即ask()方法。当我们需要等待目标Actor处理完消息并返回结果时，可以使用ask()方法向目标Actor发送消息，并等待目标Actor的返回结果。具体的使用方法可以参考Akka官方文档。
2.使用Actor调用tell()方法，如何判断谁是消息的发送者和接收者
在Akka中，使用Actor调用tell()方法发送消息时，发送者和接收者的身份可以通过消息传递过程中的ActorRef对象来确定。
在调用tell()方法时，需要指定消息的发送者，可以通过getSelf()方法获取当前Actor的ActorRef对象，然后将其作为sender参数传递给tell()方法。在接收到消息时，可以通过getSender()方法获取消息的发送者，其返回值是消息发送者的ActorRef对象。
以下是一个示例代码：
public class MyActor extends AbstractActor {
@Override
public Receive createReceive() {
return receiveBuilder()
.match(String.class, message -> {
ActorRef sender = getSender();
System.out.println("Received message: " + message + ", sent by: " + sender.path());
})
.build();
}
}
public class Main {
public static void main(String[] args) {
ActorSystem system = ActorSystem.create("myActorSystem");
ActorRef myActor = system.actorOf(Props.create(MyActor.class), "myActor");
myActor.tell("Hello, world!", ActorRef.noSender());
}
}
在这个示例中，我们创建了一个MyActor类，并在其中定义了一个处理字符串消息的方法。在方法中，我们通过getSender()方法获取消息的发送者，并将其打印出来。在Main类中，我们创建了一个ActorSystem，并创建了一个MyActor的实例。然后，我们使用tell()方法向MyActor发送了一条消息。由于我们在发送消息时指定了ActorRef.noSender()作为sender参数，因此这条消息没有指定发送者。在MyActor中，getSender()方法返回值应该为null。
3.ask()
在Akka中，除了使用tell()方法发送消息，还可以使用ask()方法向Actor发送请求并等待响应。ask()方法会返回一个Future对象，该对象代表了Actor的响应结果，可以使用Future的方法来等待结果或处理响应结果。
以下是ask()方法的详细解释：
1.ask()方法的基本使用方式：
Future<Object> future = Patterns.ask(actorRef, message, timeout);
其中，actorRef表示消息的接收者，message表示要发送的消息，timeout表示超时时间。ask()方法会立即返回一个Future对象，可以使用Future的方法等待响应结果。
2.ask()方法的返回值类型：
ask()方法返回的是Future<Object>对象，其中Object表示Actor的响应结果类型。如果需要获得具体的响应结果，需要在接收到响应后对Future对象进行处理。
3.ask()方法的超时机制：
在调用ask()方法时，需要指定一个超时时间，超时时间表示等待Actor响应的最长时间。如果超过了超时时间，ask()方法会抛出TimeoutException异常。
4.ask()方法的错误处理：
如果Actor在处理消息时发生了异常，ask()方法会返回一个包含异常信息的Future对象。因此，我们需要在处理Future对象时注意检查异常。
下面是一个示例代码，演示如何使用ask()方法向Actor发送请求并处理响应：
public class MyActor extends AbstractActor {
@Override
public Receive createReceive() {
return receiveBuilder()
.match(String.class, message -> {
String response = "Hello, " + message;
getSender().tell(response, getSelf());
})
.build();
}
}
public class Main {
public static void main(String[] args) throws Exception {
ActorSystem system = ActorSystem.create("myActorSystem");
ActorRef myActor = system.actorOf(Props.create(MyActor.class), "myActor");
Timeout timeout = Timeout.create(Duration.ofSeconds(5));
Future<Object> future = Patterns.ask(myActor, "world", timeout);
String response = (String) Await.result(future, timeout.duration());
System.out.println(response);
system.terminate();
}
}
在这个示例中，我们创建了一个MyActor类，并在其中定义了一个处理字符串消息的方法。在方法中，我们将字符串加上"Hello, "前缀，并将其发送回发送者。在Main类中，我们创建了一个ActorSystem，并创建了一个MyActor的实例。然后，我们使用ask()方法向MyActor发送了一条消息，请求MyActor将字符串加上"Hello, "前缀。ask()方法返回一个Future对象，我们使用Await.result()方法等待响应结果，并将结果转换为字符串。最后，我们打印出了响应结果。
总之，在Akka中，ask()方法可以用于向Actor发送请求并等待响应。ask()方法返回一个Future对象，我们可以使用Future的方法等待响应结果。注意，ask()方法有超时机制，需要指定一个超时时间，并在处理Future对象时注意检查异常。
4.Future详解
在Akka中，Future是一个表示异步操作结果的对象，它代表一个计算的结果或异常，可以被用于处理异步结果。Future的作用在于，当需要执行一个比较耗时的操作时，它可以在后台执行这个操作，同时不会阻塞当前线程，使得程序可以更加高效地执行。
下面我们来详细了解一下Akka中的Future：
- Future的创建
在Akka中，可以使用Java的CompletableFuture类或者Akka自带的Patterns类来创建Future对象。以Patterns类为例，可以使用PatternsCS.ask()方法来创建一个Future对象：
Future<Object> future = PatternsCS.ask(actorRef, message, timeout);
其中actorRef表示接收消息的Actor，message表示要发送的消息，timeout表示超时时间。
- Future的使用
当Future对象被创建后，可以使用Future对象的一些方法来处理异步操作的结果，这些方法包括：
-
get()：获取Future对象的计算结果，该方法会阻塞当前线程，直到Future的计算结果返回为止。
-
isDone()：判断Future对象的计算是否已经完成。
-
isCancelled()：判断Future对象的计算是否已经被取消。
-
onComplete()：注册一个回调函数，在Future计算完成或出现异常时执行该函数。
-
map()：对Future的计算结果进行转换。
-
flatMap()：对Future的计算结果进行转换，并返回另一个Future对象。
-
filter()：对Future的计算结果进行过滤。
Future的错误处理
当Future的计算过程中出现了异常，可以使用try-catch语句或者onComplete()方法的回调函数来处理异常。
以下是一个示例代码，演示如何使用Future：
public class MyActor extends AbstractActor {
@Override
public Receive createReceive() {
return receiveBuilder()
.match(String.class, message -> {
String response = "Hello, " + message;
getSender().tell(response, getSelf());
})
.build();
}
}
public class Main {
public static void main(String[] args) throws Exception {
ActorSystem system = ActorSystem.create("myActorSystem");
ActorRef myActor = system.actorOf(Props.create(MyActor.class), "myActor");
Timeout timeout = Timeout.create(Duration.ofSeconds(5));
Future<Object> future = PatternsCS.ask(myActor, "world", timeout);
future.onComplete(new OnComplete<Object>() {
@Override
public void onComplete(Throwable failure, Object success) {
if (failure != null) {
System.out.println("Error: " + failure.getMessage());
} else {
String response = (String) success;
System.out.println(response);
}
}
}, system.dispatcher());
system.terminate();
}
}
在这个示例中，我们创建了一个MyActor类，并在其中定义了一个处理字符串消息的方法。在方法中，我们将字符串加上"Hello, "前缀，并将其发送回发送者。在Main类中，我们创建了一个ActorSystem，并创建了一个MyActor的实例。然后，我们使用ask()方法向MyActor发送了一条消息，请求MyActor将字符串加上"Hello,"前缀并返回结果。我们使用了Future对象来异步地处理结果，并注册了一个onComplete()回调函数来处理异步操作的结果。当异步操作完成时，该函数会被自动调用，并检查计算结果是否包含异常。如果有异常，它将打印异常消息；否则，它将打印字符串"Hello, world"。最后，我们关闭了ActorSystem。
需要注意的是，当使用Future时，应该尽量避免使用阻塞式的方法（如get()方法），而应该使用异步式的方法（如onComplete()方法）。这是因为阻塞式的方法会在等待Future的计算结果时阻塞当前线程，降低了程序的效率。
除了使用Patterns类来创建Future对象外，我们还可以使用Akka提供的异步API，如ask()方法和pipeTo()方法。这些方法可以帮助我们更加方便地处理异步操作的结果，提高程序的执行效率。
扫一扫
954
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
