Akka Actor_Future的使用

常见的是通过Actor的tell方法给另外一个actor发送消息,但是actor 和 future怎么交互,发送消息,如下,

Future<Object> future = Patterns.ask(a, "are you ready?", timeout);

做了一个Future 和 Actor 结合使用的例子,如下,

package com.usoft;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import akka.pattern.Patterns;
import akka.util.Timeout;
import scala.concurrent.Await;
import scala.concurrent.Future;
import scala.concurrent.duration.Duration;

/**
 * Created by liyanxin on 2015/1/8.
 */
public class HelloFuture {

    public static class A extends UntypedActor {

        private final LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        @Override
        public void onReceive(Object message) throws Exception {
            if (message instanceof String) {
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " sleep end");
                System.out.println("接收的消息:" + message);
                // 返回一个消息
                this.getSender().tell("hello world", this.getSelf());
                System.out.println("sender path=" + this.getSender().path());
                getContext().stop(this.getSelf());
                log.info("|||{} has stop", this.getSelf().path());
            }
        }
    }

    public static void main(String args[]) throws Exception {
        System.out.println(Thread.currentThread().getName());
        ActorSystem system = ActorSystem.create("mySystem");
        ActorRef a = system.actorOf(Props.create(A.class), "helloWorld");
        Timeout timeout = new Timeout(Duration.create(5, "seconds"));
        Future<Object> future = Patterns.ask(a, "are you ready?", timeout);

        // This will cause the current thread to block and wait for the UntypedActor to ‘complete’
        // the Future with it’s reply.
        // 在这里会阻塞到 Await.result 方法上,但这会导致性能的损失。
        String result = (String) Await.result(future, timeout.duration());
        System.out.println(result);
    }

}

运行结果,

main

mySystem-akka.actor.default-dispatcher-4 sleep end

接收的消息:are you ready?

hello world

sender path=akka://mySystem/temp/$a

[INFO] [01/08/2015 16:55:11.267] [mySystem-akka.actor.default-dispatcher-4] [akka://mySystem/user/helloWorld] |||akka://mySystem/user/helloWorld has stop

Maven依赖库

<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-actor_2.11</artifactId>
    <version>2.3.8</version>
</dependency>

结果是出来了,但是代码是如何工作的,这些细节还是不清楚的。

=========================END=========================

时间: 2024-10-07 12:31:32

Akka Actor_Future的使用的相关文章

Akka(15): 持久化模式:AtLeastOnceDelivery-消息保证送达模式

消息保证送达是指消息发送方保证在任何情况下都会至少一次确定的消息送达.AtleastOnceDelivery是一个独立的trait,主要作用是对不确定已送达的消息进行补发,这是一种自动的操作,无需用户干预.既然涉及到消息的补发,就不可避免地影响发送方和接收方之间消息传递的顺序.接收方重复收到相同的消息等问题,这些用户必须加以关注.从另一个方面,AtleastOnceDelivery模式保证了强韧性Actor系统的不丢失消息,这项要求可能是一些系统的核心要求. AtleastOnceDeliver

使用AKKA做分布式爬虫的思路

上周公司其他小组在讨论做分布式爬虫,我也思考了一下,提了一个方案,就是使用akka分布式rpc框架来做,自己写master和worker程序,client向master提交begin任务或者其它爬虫需求,master让worker去爬网页,worker都是kafka的同一个group然后从kafka里面拉取数据(URL),然后处理爬了的网页,解析内容,把爬下来的网页通过正则表达式匹配出嵌套的网页,然后请求actor判断是否爬过(防止生成有向图,让其变成树形结构)(这里应该是个单独的actor,这

SPARK如何使用AKKA实现进程、节点通信

SPARK如何使用AKKA实现进程.节点通信 <深入理解Spark:核心思想与源码分析>一书前言的内容请看链接<深入理解SPARK:核心思想与源码分析>一书正式出版上市 <深入理解Spark:核心思想与源码分析>一书第一章的内容请看链接<第1章 环境准备> <深入理解Spark:核心思想与源码分析>一书第二章的内容请看链接<第2章 SPARK设计理念与基本架构> <深入理解Spark:核心思想与源码分析>一书第三章第一部分

Hello,Akka

版权声明:转载时请以超链接形式标明文章原始出处和作者信息及本声明http://www.blogbus.com/dreamhead-logs/235916459.html 只要稍微了解过一些Scala,这门JVM上广受关注的程序设计语言,你一定会对其中的一个Actor特性印象深刻.Actor是另一种进行并发计算的方式.通过在不同的Actor之间彼此发送消息,我们会惊喜地发现,那令人纠结的锁将不再困扰我们. 不过,那是Scala的世界,作为一个Java程序员难道只有艳羡的份吗?显然不是.Akka把A

初解,Scala语言中基于Actor的并发编程的机制,并展示了在Spark中基于Scala语言的Actor而产生的消息驱动框架Akka的使用,

Scala深入浅出实战中级--进阶经典(第66讲:Scala并发编程实战初体验及其在Spark源码中应用解析)内容介绍和视频链接 2015-07-24 DT大数据梦工厂 从明天起,做一个勤奋的人 看视频.下视频,分享视频 DT大数据梦工厂-Scala深入浅出实战中级--进阶经典:第66讲:Scala并发编程实战初体验及其在Spark源码中的应用解析 本期视频通过代码实战详解了Java语言基于加锁的并发编程模型的弊端以及Scala语言中基于Actor的并发编程的机制,并展示了在Spark中基于Sc

akka概述

概述 并发分布式框架:作者号称可以在jvm用来构建高并发,分布式,消息驱动式的程序.依据当前我使用的范围还只局限于并发与任务调度的使用层面上, 在这两方面的表现还是很令我满意的. 当前自己所熟悉的互联网开发模式有 ------------------------------------------------------------ 借组于队列,异步处理问题,处理不需要及时作出响应的任务 使用缓存,减少对常用数据的查询 使用内存数据库 加快查询某些需要快速查询响应的速度 数据库,主从模式,读写分

akka入门-热插拔(become和unbecome)

Akka支持在运行时对角色消息循环 (例如它的的实现)进行实时替换: 在角色中调用getContext.become 方法. 热替换的代码被存在一个栈中,可以被pushed(replacing 或 adding 在顶部)和popped. become一个特别好的例子是用它来实现一个有限状态机. 使用Become/Unbecome特性还可以很方便的实现状态转换机. 1.动态替换方法 import akka.actor.ActorRef; import akka.actor.ActorSystem;

[Akka]发送一条消息的内部流程

本想通过了解一下Akka-actor工程中主要的类的概念,来看下Akka内部运作的机制.无奈里边的类的确太多,注释中对每个类的功能也没有足够的解释.所以还是通过debug的方式,找个入手点,看一下互相之间调用的关系. 最初的选择是看一下ActorSystem的实始化过程,但发现难度挺大,因为这个初始化工作是为以后的行为做准备,所以仅根据初始化的动作,难以了解其目的是什么.所以就试着从消息发送的过程了解起,发现这个逻辑更好理解. 下面来看一下其执行过程吧.代码如下,使用默认的配置. object

scala下使用akka计算pi

Akka 是一个用 Scala 编写的库,用于简化编写容错的.高可伸缩性的 Java 和 Scala 的 Actor 模型应用.它已经成功运用在电信行业.系统几乎不会宕机(高可用性 99.9999999 % 一年只有 31 ms 宕机. 用akka计算pi,计算公式: 这样,我们把这个公式每连续的elements个分成一段,一共分成message段. 然后开worker个actor同时计算,把结果合并.算出最终结果和耗时. 一:计算某一段的actor 我们需要一个工作actor,用来计算某一段的