Akka并发编程——第三节：Actor模型（二）

最新推荐文章于 2024-08-06 15:42:41 发布
最新推荐文章于 2024-08-06 15:42:41 发布
阅读量214 收藏
点赞数
文章标签： scala 大数据
原文链接：https://yq.aliyun.com/articles/60302
版权

本节主要内容：

  1. Actor API解析

1. Actor API解析

Actor中的主要成员变量和方法定义如下：

package akka.actor
trait Actor extends scala.AnyRef {
  type Receive = akka.actor.Actor.Receive

  //context变量暴露当前Actor的上下文信息及当前消息
  implicit val context : akka.actor.ActorContext = { /* compiled code */ }

  //self作为当前ActorRef的引用
  implicit final val self : akka.actor.ActorRef = { /* compiled code */ }

  //当前Actor接收到最后一条消息对应的消息发送者(Actor）
  final def sender() : akka.actor.ActorRef = { /* compiled code */ }

  //receive方法，抽象方法，定义Actor的行为逻辑
  def receive : akka.actor.Actor.Receive

  //内部使用API 
  protected[akka] def aroundReceive(receive : akka.actor.Actor.Receive, msg : scala.Any) : scala.Unit = { /* compiled code */ }
  protected[akka] def aroundPreStart() : scala.Unit = { /* compiled code */ }
  protected[akka] def aroundPostStop() : scala.Unit = { /* compiled code */ }
  protected[akka] def aroundPreRestart(reason : scala.Throwable, message : scala.Option[scala.Any]) : scala.Unit = { /* compiled code */ }
  protected[akka] def aroundPostRestart(reason : scala.Throwable) : scala.Unit = { /* compiled code */ }


   //监督策略，用于Actor容错处理
  def supervisorStrategy : akka.actor.SupervisorStrategy = { /* compiled code */ }

  //Hook方法，用于Actor生命周期监控 
  @scala.throws[T](classOf[scala.Exception])
  def preStart() : scala.Unit = { /* compiled code */ }
  @scala.throws[T](classOf[scala.Exception])
  def postStop() : scala.Unit = { /* compiled code */ }
  @scala.throws[T](classOf[scala.Exception])
  def preRestart(reason : scala.Throwable, message : scala.Option[scala.Any]) : scala.Unit = { /* compiled code */ }
  @scala.throws[T](classOf[scala.Exception])
  def postRestart(reason : scala.Throwable) : scala.Unit = { /* compiled code */ }


  //发送给Actor的消息，Actor没有定义相应的处理逻辑时，会调用此方法
  def unhandled(message : scala.Any) : scala.Unit = { /* compiled code */ }
}
object Actor extends scala.AnyRef {
  type Receive = scala.PartialFunction[scala.Any, scala.Unit]

  //空的行为逻辑
  @scala.SerialVersionUID(1)
  object emptyBehavior extends scala.AnyRef with akka.actor.Actor.Receive {
    def isDefinedAt(x : scala.Any) : scala.Boolean = { /* compiled code */ }
    def apply(x : scala.Any) : scala.Nothing = { /* compiled code */ }
  }
  //Sender为null
  @scala.SerialVersionUID(1)
  final val noSender : akka.actor.ActorRef = { /* compiled code */ }
}

（1） Hook方法，preStart()、postStop()方法的使用

/*
 *Actor API: Hook方法
 */
  object Example_05 extends App{
    import akka.actor.Actor
    import akka.actor.ActorSystem
    import akka.actor.Props


    class FirstActor extends Actor with ActorLogging{
      //通过context.actorOf方法创建Actor
      var child:ActorRef = _

      //Hook方法，preStart()，Actor启动之前调用，用于完成初始化工作
      override def preStart(): Unit ={
        log.info("preStart() in FirstActor")
        //通过context上下文创建Actor
        child = context.actorOf(Props[MyActor], name = "myChild")
      }
      def receive = {
        //向MyActor发送消息
        case x => child ! x;log.info("received "+x)
      }

      //Hook方法，postStop()，Actor停止之后调用
      override def postStop(): Unit = {
        log.info("postStop() in FirstActor")
       }
    }


    class MyActor extends Actor with ActorLogging{
      //Hook方法，preStart()，Actor启动之前调用，用于完成初始化工作
      override def preStart(): Unit ={
        log.info("preStart() in MyActor")
      }
      def receive = {
        case "test" => log.info("received test")
        case _      => log.info("received unknown message")
      }

      //Hook方法，postStop()，Actor停止之后调用
      override def postStop(): Unit = {
        log.info("postStop() in MyActor")
      }
    }

    val system = ActorSystem("MyActorSystem")
    val systemLog=system.log

    //创建FirstActor对象
    val myactor = system.actorOf(Props[FirstActor], name = "firstActor")

    systemLog.info("准备向myactor发送消息")
    //向myactor发送消息
    myactor!"test"
    myactor! 123
    Thread.sleep(5000)
    //关闭ActorSystem，停止程序的运行
    system.shutdown()
  }

代码运行结果：

[INFO] [04/02/2016 17:04:49.607] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 17:04:49.607] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor
[INFO] [04/02/2016 17:04:49.607] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 17:04:49.607] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 17:04:49.608] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myChild] preStart() in MyActor
[INFO] [04/02/2016 17:04:49.608] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myChild] received test
[INFO] [04/02/2016 17:04:49.608] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myChild] received unknown message
[INFO] [04/02/2016 17:04:54.616] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myChild] postStop() in MyActor
[INFO] [04/02/2016 17:04:54.617] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] postStop() in FirstActor

在代码

 class FirstActor extends Actor with ActorLogging{
      //通过context.actorOf方法创建Actor
      var child:ActorRef = _

      //Hook方法，preStart()，Actor启动之前调用，用于完成初始化工作
      override def preStart(): Unit ={
        log.info("preStart() in FirstActor")
        //通过context上下文创建Actor
        child = context.actorOf(Props[MyActor], name = "myChild")
      }
      def receive = {
        //向MyActor发送消息
        case x => child ! x;log.info("received "+x)
      }

      //Hook方法，postStop()，Actor停止之后调用，用于完成初始化工作
      override def postStop(): Unit = {
        log.info("postStop() in FirstActor")
      }
    }

中分别对postStop、preStart方法进行了重写，在preStart方法中通过代码

 child = context.actorOf(Props[MyActor], name = "myChild")

对成员变量child进行初始化，然后在postStop方法中使用

 //通过context上下文停止MyActor的运行
        context.stop(child)

停止MyActor的运行。在使用代码

//创建FirstActor对象
val myactor = system.actorOf(Props[FirstActor], name = "firstActor")

创建FirstActor时，便会调用preStart方法完成MyActor的创建，因此首先会执行FirstActor中的preStart()方法

dispatcher-4] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor

然后在创建MyActor时执行MyActor中定义的preStart方法

[INFO] [04/02/2016 17:04:49.608] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myChild] preStart() in MyActor

在执行

//关闭ActorSystem，停止程序的运行
    system.shutdown()

FirstActor作为MyActor的Supervisor，会先停止MyActor，再停止自身，因此先调用MyActor的postStop方法，再调用FirstActor的postStop方法。

（2） 成员变量self及成员方法sender方法的使用

整体代码如下：

  /*
 *Actor API:成员变量self及sender()方法的使用
 */
  object Example_05 extends App{
    import akka.actor.Actor
    import akka.actor.ActorSystem
    import akka.actor.Props


    class FirstActor extends Actor with ActorLogging{
      //通过context.actorOf方法创建Actor
      var child:ActorRef = _

      override def preStart(): Unit ={
        log.info("preStart() in FirstActor")
        //通过context上下文创建Actor
        child = context.actorOf(Props[MyActor], name = "myActor")
      }
      def receive = {
        //向MyActor发送消息
        case x => child ! x;log.info("received "+x)
      }


    }


    class MyActor extends Actor with ActorLogging{
      self!"message from self reference"
      def receive = {
        case "test" => log.info("received test");sender()!"message from MyActor"
        case "message from self reference"=>log.info("message from self refrence")
        case _      => log.info("received unknown message");
      }

    }

    val system = ActorSystem("MyActorSystem")
    val systemLog=system.log

    //创建FirstActor对象
    val myactor = system.actorOf(Props[FirstActor], name = "firstActor")

    systemLog.info("准备向myactor发送消息")
    //向myactor发送消息
    myactor!"test"
    myactor! 123
    Thread.sleep(5000)
    //关闭ActorSystem，停止程序的运行
    system.shutdown()
  }

运行结果：

[INFO] [04/02/2016 18:40:37.805] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 18:40:37.805] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] message from self refrence
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received message from MyActor
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message

代码：

class MyActor extends Actor with ActorLogging{
      self!"message from self reference"
      def receive = {
        case "test" => log.info("received test");sender()!"message from MyActor"
        case "message from self reference"=>log.info("message from self refrence")
        case _      => log.info("received unknown message");
      }

    }

中使用

self!"message from self reference"

向自身发送了一条消息，receive方法通过

        case "message from self reference"=>log.info("message from self refrence")

对这条消息进行处理。receive方法在处理

def receive = {
        case "test" => log.info("received test");sender()!"message from MyActor"

“test”消息时，会调用

sender()!"message from MyActor"

向sender（本例中为FirstActor）发送”message from MyActor”消息，FirstActor使用

 def receive = {
        //向MyActor发送消息
        case x => child ! x;log.info("received "+x)
      }

处理消息时又向MyActor回送该消息，因此最终的输出有两个unknown message，分别对应123和”message from MyActor”

[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 18:40:37.806] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message

（3） unhandled方法的使用

unhandled方法用于处理没有被receive方法处理的消息，下面的代码给出的是当不重写unhandled方法时的代码

/*
*Actor API:unhandled方法
*/
object Example_06 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props
  class FirstActor extends Actor with ActorLogging{
    def receive = {
      //向MyActor发送消息
      case "test" => log.info("received test")
    }


  }
  val system = ActorSystem("MyActorSystem")
  val systemLog=system.log

  //创建FirstActor对象
  val myactor = system.actorOf(Props[FirstActor], name = "firstActor")

  systemLog.info("准备向myactor发送消息")
  //向myactor发送消息
  myactor!"test"
  myactor! 123
  Thread.sleep(5000)
  //关闭ActorSystem，停止程序的运行
  system.shutdown()
}

代码输出：

[INFO] [04/02/2016 19:14:11.992] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 19:14:11.992] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received test

不难看出，对于

 myactor! 123

发送的这条消息没有被处理，没有任何的处理逻辑。在实际开发过程中，可能会对不能被处理的消息增加一些应对逻辑，此时可以重写unhandled方法，代码如下：

/*
*Actor API:unhandled方法的使用
*/
object Example_06 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props


  class FirstActor extends Actor with ActorLogging{
    def receive = {
      //向MyActor发送消息
      case "test" => log.info("received test")
    }

    //重写unhandled方法
    override def unhandled(message: Any): Unit = {
      log.info("unhandled message is {}",message)
    }
  }



  val system = ActorSystem("MyActorSystem")
  val systemLog=system.log

  //创建FirstActor对象
  val myactor = system.actorOf(Props[FirstActor], name = "firstActor")

  systemLog.info("准备向myactor发送消息")
  //向myactor发送消息
  myactor!"test"
  myactor! 123
  Thread.sleep(5000)
  //关闭ActorSystem，停止程序的运行
  system.shutdown()
}

代码输出结果：

[INFO] [04/02/2016 19:17:18.458] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 19:17:18.458] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 19:17:18.458] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] unhandled message is 123

其它如preRestart等方法的使用将在Akka容错部分进行讲解。

Scala学习（公众微信号：ScalaLearning）每天为大家带来一点Scala语言、Spark、Kafka、Flink、AKKA等大数据技术干货及相关技术资讯。技术永无止境，勇攀高峰，一往直前！
觉得文章不错？扫描关注
这里写图片描述

weixin_34408624
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Akka并发编程——第四节：Actor模型（三）
摇摆少年梦的技术博客
04-02 9934
本将主要内容： 1. Actor引用、Actor路径1. Actor引用、Actor路径下图是Akka官方文档中给出的一张图该图清晰地说明了ActorPath，ActorRef，Actor及ActorSystem之间的关系，并说明了Actor整体的层次结构。前面我们提到，Akka应用程序会持有一个名称为user的Actor，该Actor被称为guardian supervisor（守卫监督器），无
Akka并发编程——第二节：Actor模型(一）
春华秋实
07-13 523
本节主要内容 定义Actor创建Actor 1. 定义Actor 通过扩展akka.actor.Actor 特质并实现receive方法来定义Actor，代码示例如下 //通过扩展Actor并实现receive方法来定义Actor class MyActor extends Actor { //获取LoggingAdapter，用于日志输出 val log = Logg
Akka并发编程——第五节：Actor模型（四） 停止Actor
春华秋实
07-18 2659
本节主要内容： 1. 停止Actor 1. 停止Actor （1）通过ActorSystem.shutdown方法停止所有 Actor的运行 /* *停止Actor:ActorSystem.shutdown方法 */ object Example_10 extends App{ import akka.actor.Actor import akka.actor.ActorSyst
Akka并发编程——第五节：Actor模型（四）
摇摆少年梦的技术博客
04-02 5922
本节主要内容： 1. 停止Actor1. 停止Actor（1）通过ActorSystem.shutdown方法停止所有 Actor的运行/* *停止Actor:ActorSystem.shutdown方法 */ object Example_10 extends App{ import akka.actor.Actor import akka.actor.ActorSystem imp
Akka并发编程——第八节：Actor模型（七）
热门推荐
摇摆少年梦的技术博客
06-26 1万+
本节主要内容停止运行Typed Actor当Typed Actor不再需要时要将其停止，有3种方法停止Typed Actor的运行： （1）通过system.shutdown()停止ActorSystem中所有的Typed Actor； （2）调用TypedActor(system).stop(mySquarer)停止指定的Typed Actor； （3）调用Typed
Akka并发编程——第七节：Actor模型（六）
摇摆少年梦的技术博客
06-26 1万+
主要内容： 1. Typed Actor定义 2. Typed Actor创建 3. 消息发送1. Typed Actor定义Akka中的Typed Actor是Active Objects设计模式的实现，Active Objects模式将方法的执行和方法的调用进行解耦合，从而为程序引入并发性。Typed Actor由公用的接口和对应实现两部分构成，其后面深层次的实现使用的是代理模式，即通过使
Akka并发编程——第六节：Actor模型（五）
春华秋实
07-18 436
本章主要内容： 1. !消息发送，Fire-and-Forget消息模型 2. ？消息发送，Send-And-Receive-Future消息模型 Akka提供了两种消息模型：fire-and-forget和Send-And-Receive-Future。fire-and-forget是一种单向消息发送模型，指的是异步发送消息，通过异步发送消息且消息发送后可以立即返回，Akka中使用?方
ActorModel:Actor模型（并发计算模型）
05-30
- **事件驱动编程**：Actor模型与事件驱动编程有紧密关系，因为演员通过接收和响应事件消息来执行操作。 - **进程间通信（IPC）**：Actor模型中的消息传递类似于IPC，但更侧重于并发和并行性。 - **线程和并行...
使用Akka的Actor模型和领域驱动设计构建反应式系统
01-27
【使用Akka的Actor模型和领域驱动设计构建反应式系统】是现代软件开发中的一个重要话题。随着业务需求的不断增长，尤其是移动应用和数据驱动应用的爆发，系统必须具备高弹性和快速响应的能力。Actor模型和领域驱动...
Akka Actor模型开发库-其他
06-12
Akka是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。 Actor模型并非什么新鲜事物，它由Carl Hewitt于上世纪70年代早期提出，目的是为了解决分布式编程中一系列的编程...
akka-persistent-actor-example:羊驼，卡夫卡，React流，演员模型，阿卡
05-11
跟踪目录中每个新创建的文件并发送到kafka 特定的：处理应用程序重新启动，将已处理文件的状态保存在本地节点上（与kafka分离） 解决方案 为了列出目录中的所有文件并跟踪事件，我使用了 清单 final Source...
打造Perl中的词法分析器：深入自定义文本处理
2401_85812053的博客
08-03 567
Perl作为一种强大的文本处理语言，提供了丰富的工具来实现词法分析器（Lexer）。词法分析是编译原理中将源代码分解成一系列词素（Tokens）的过程，是构建编译器或解释器的第一步。本文将详细探讨如何在Perl中实现一个自定义的词法分析器，包括设计词法规则、实现词法分析器以及使用正则表达式进行文本匹配。
【大数据开发语言Scala的入门教程】
cz88888888666的博客
08-02 680
Scala支持函数作为一等公民，你可以使用函数字面量和高阶函数来编写函数式风格的代码。它还提供了一些函数式编程的特性，如不可变数据结构、纯函数和函数组合。Scala是静态类型语言，它提供了像整数、浮点数、字符串和布尔值等基本数据类型，以及集合类型（如数组和列表）和元组等高级数据类型。Scala是一种面向对象的语言，它允许你定义类和对象，并使用封装、继承和多态等面向对象的概念。你可以定义类和伴生对象、实现接口和扩展类。Scala提供了丰富的集合操作方法，你可以使用它们来处理数组、列表、集合和映射等数据结构。
Flink开发语言使用Java还是Scala合适？
qq_15557237的博客
08-05 229
Flink开发语言使用Java还是Scala合适？
Unable to clear output directory
SunnyRivers
08-05 149
这个错误通常发生在使用Apache Spark进行数据处理并尝试使用insertInto或overwrite方法将数据写入一个表时。报错"Unable to clear output directory"意味着Spark无法清空指定的输出目录，这通常是因为权限问题、目录不存在或目录中有文件正在被使用。任务直接的依赖关系正常来说是非常严格的，有依赖必须配置，没有依赖就别配置。这种bug是偶现的，大部分情况都不会出现，忽然某一天就报错了，重新运行就好了。
Flink开发语言使用java还是Scala合适
最新发布
七夜的博客
08-06 247
选择Java：如果团队对Java更熟悉，项目对代码的稳定性和可维护性要求高，并且需要与现有的Java生态系统集成。选择Scala：如果团队愿意尝试新的编程范式，项目需要快速迭代和开发，或者在大数据和分布式计算领域有特殊需求。最终的选择应根据团队的技能水平、项目需求、企业环境以及对新技术的接受度综合考虑。无论选择Java还是Scala，Flink都能提供强大的流处理能力，关键在于选择最适合团队和项目的语言。
Apache Flink开发时选择Java还是Scala作为编程语言
hai40587的博客
08-06 598
Apache Flink是一个开源的分布式流处理框架，用于处理无界和有界数据流。它以其高吞吐量、低延迟、精确的状态管理和强大的容错能力而闻名。Flink支持多种编程语言，其中Java和Scala是最常用的两种。
Akka 演化：Actor并发模型与分布式应用指南
Akka是一套用于构建并发和分布式应用程序的开源工具和运行时环境，受到Erlang的并发模型启发，特别强调Actor模型的使用。这份文档详细介绍了Akka的相关概念、术语、Actor系统、故障容忍、调度器、持久化、网络和集群...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值