Akka框架学习

最新推荐文章于 2024-05-13 10:03:05 发布
最新推荐文章于 2024-05-13 10:03:05 发布
阅读量1.6k 收藏 6
点赞数 2
分类专栏： 大数据 文章标签： akka

Akka框架学习

转载自Spark修炼之道

一、并发编程简介

多核处理器的出现使并发编程（Concurrent Programming）成为开发人员必备的一项技能，许多现代编程语言都致力于解决并发编程问题。并发编程虽然能够提高程序的性能，但传统并发编程的共享内存通信机制对开发人员的编程技能要求很高，需要开发人员通过自身的专业编程技能去避免死锁、互斥等待及竞争条件（Race Condition）等，熟悉Java语言并发编程的读者们对这些问题的理解会比较深刻，这些问题使得并发编程比顺序编程要困难得多。

Scala语言并没有直接使用Java语言提供的并发编程库，而是通过Actor模型来解决Java并发编程中遇到的各种问题，为并发编程提供了更高级的抽象。

1、重要概念

（1）并发和并行

并发和并行从宏观来看，都是为进行多任务运行，但并发（Concurrency）和并行（parallelism）两者之间是有区别的。

  • 并行是指两个或者两个以上任务在同一时刻同时运行
  • 并发是指两个或两个以上的任务在同一时间段内运行，即一个时间段中有几个任务都处于已启动运行到运行完毕之间，这若干任务在同一CPU上运行但任一个时刻点上只有一个任务运行。

这里写图片描述
图1 进程、线程模型

图1给出了多核处理器下的现代操作系统进程和线程模型，图中进程2的线程1被调用度到处理器的核2上运行、进程3的线程1被调度到处理器的核3上运行，进程2的线程1和进程3的线程1是并行的，它们可以同时运行，而进程1的线程1和线程2都调度到处理器的核1上运行，此外它们还共享线程1的内存空间，在运行时面临着资源竞争包括CPU、内存及其它如IO等，它们在同一时候只能运行一个，但在一段时间内都可以运行，因此进程1的线程1和线程2是并发执行的。

（2）横向扩展和纵向扩展
  • 纵向扩展（Scale Up）指的是增加程序的进度或线程数量，提高程序的并发性；
  • 横向扩展（Scale Out）指的是程序可以扩展到其它机器上运行，即通过分布式系统来提到程序的并行度。

传统的Java并发编程模型不容易进行纵向扩展，因此并发的线程数越多，程序行为便会变得很难理解和控制，更多的线程加入到资源竞争，出现死锁等情况的概率增加。横向扩展比纵向扩展困难更大，此时的程序变为分布式环境下的应用，情况更为复杂，对开发人员的要求更高。Scala提供的Actor模型可以解决并发应用程序的横向扩展和纵向扩展问题，如图2、图3给出了基本Actor模型的横向扩展和纵向扩展。

这里写图片描述
图2 纵向扩展

这里写图片描述
图3 横向扩展

2、Actor模型

在使用Java语言进行并发编程时，需要特别关注共享的数据结构，线程间的资源竞争容易导致死锁等问题，而Actor模型便是要解决线程和锁带来的问题。

Actor是一种基于事件（Event-Based）的轻量级线程，在使用Actor进行并发编程时只需要关注代码结构，而不需要过分关注数据结构，因此Actor最大限度地减少了数据的共享。

Actor由三个重要部分组成，它们是状态（state），行为（Behavior）和邮箱（Mailbox）。Actor与Actor之间的交互通过消息发送来完成，Actor模型如图4所示，状态指的是Actor对象的变量信息，它可以是Actor对象中的局部变量、占用的机器资源等，状态只会根据Actor接受的消息而改变，从而避免并发环境下的死锁等问题；行为指的是Actor的计算行为逻辑，它通过处理Actor接收的消息而改变Actor状态；邮箱（mailbox）建立起Actor间的连接，即Actor发送消息后，另外一个Actor将接收的消息放入到邮箱中待后期处理，邮箱的内部实现是通过队列来实现的，队列可以是有界的（Bounded）也可以是无界的（Unbounded），有界队列实现的邮箱容量固定，无界队列实现的邮箱容易不受限制。

这里写图片描述
图4 Actor模型

不难看出，Actor模型是对现实世界的高度抽象，它具有如下特点：

  1. Actor之间使用消息传递机制进行通信，传递的消息使用的是不可变消息；
  2. Actor之间并不共享数据结构，如果有数据共享则通过消息发送的方式进行；
  3. 各Actor都有对应的mailbox，如果其它Actor向该Actor发送消息，消息将入队待后期处理；
  4. Actor间的消息传递通过异步的方式进行，即消息的发送者发送完消息后不必等待回应便可以返回继承处理其它任务。

3、Akka并发编程框架

Scala语言中原生地支持Actor模型，只不过功能还不够强大，从Scala 2.10版本之后，Akka框架成为Scala包的一部分，可以在程序中直接使用。Akka框架是一个以Actor模型为基础构建的基于事件的并发编程框架，底层使用Scala语言实现，提供Java和Scala两种API，它属于LightBend公司（原Typesafe公司）体系结构的一部分，如图5所示。

这里写图片描述
图5 Lightbend 体系结构

Akka框架意在简化高并发、可扩展及分布式应用程序的设计，它具有如下优势：

  1. 使用Akka框架编写的应用程序既可以横向扩展（Scale Out）、也可纵向扩展（Scale Up）。
  2. 编写并发应用程序更简单，Akka提供了更高的抽象，开发人员只需要专注于业务逻辑，而无需像Java语言那样需要处理底级语义如线程、锁及非阻塞IO等。
  3. 高容错，Akka使用“let it crashes”机制，当Actor出错时可以快速恢复。
  4. 事件驱动的架构，Akka中的Actor之间的通信采用异步消息发送，能够完美支持事件驱动。
  5. 位置透明，无论是Actor运行在本地机器还是远程机器上，对于用户来说都是透明的，这极大地简化了多核处理器和分布式系统上的应用程序编程。
  6. 事务支持能力，支持软件事务内存（software transactional memory，STM），使Actor具有原子消息流的操作能力。

Akka框架由下列十个组件构成：

  1. akka-actor ：包括经典的Actor、Typed Actors、IO Actor等
  2. akka-remote：远程Actor
  3. akka-testkit：测试Actor系统的工具箱
  4. akka-kernel ：Akka微内核，用于运行精简的微型应用程序服务器，无需运行于Java应用服务器上。
  5. akka-transactor ：Transactors 即支持事务的 actors，集成了Scala STM
  6. akka-agent – 代理, 同样集成了Scala STM
  7. akka-camel – 集成Apache Camel
  8. akka-zeromq – 集成ZeroMQ 消息队列
  9. akka-slf4j – 支持SLF4J 日志功能
  10. akka-filebased-mailbox – 支持基于文件的mailbox

二、Actor模型

1. 定义Actor

通过扩展akka.actor.Actor 特质并实现receive方法来定义Actor，代码示例如下

//通过扩展Actor并实现receive方法来定义Actor
class MyActor extends Actor {
    //获取LoggingAdapter，用于日志输出
    val log = Logging(context.system, this)

    //实现receive方法，定义Actor的行为逻辑，返回的是一个偏函数
    def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }
  }

receive方法被定义在Actor当中，方法标签如下

//Actor中的receive方法定义，
type Receive = PartialFunction[Any, Unit]
def receive: Actor.Receive

下面给出其完整使用代码：

object Example_01 extends App{
  import akka.actor.Actor
  import akka.event.Logging
  import akka.actor.ActorSystem
  import akka.actor.Props

  class MyActor extends Actor {
    val log = Logging(context.system, this)

    def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }
  }
 //创建ActorSystem对象
  val system = ActorSystem("MyActorSystem")
  //返回ActorSystem的LoggingAdpater
  val systemLog=system.log
  //创建MyActor,指定actor名称为myactor
  val myactor = system.actorOf(Props[MyActor], name = "myactor")

  systemLog.info("准备向myactor发送消息")
  //向myactor发送消息
  myactor!"test"
  myactor! 123

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

代码运行结果：

[INFO] [04/02/2016 09:29:54.223] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 09:29:54.224] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/myactor] received test
[INFO] [04/02/2016 09:29:54.224] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/myactor] received unknown message

输出“[INFO] [04/02/2016 09:29:54.224] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/myactor] received test”中的[MyActorSystem-akka.actor.default-dispatcher-3]为对应的线程名，[akka://MyActorSystem/user/myactor]为Actor路径信息， received test为

def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }

方法处理后的输出。关于[akka://MyActorSystem/user/myactor]路径信息，将在后续内容中进行详细阐述。

也可以通过混入ActorLogging来实现日志功能，具体代码如下：

class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }
  }

ActorLogging的定义如下：

trait ActorLogging { this: Actor =>
  private var _log: LoggingAdapter = _

  def log: LoggingAdapter = {
    // only used in Actor, i.e. thread safe
    if (_log eq null)
      _log = akka.event.Logging(context.system, this)
    _log
  }

}

完整代码如下：

/*
 *定义Actor时混入ActorLogging
 */
object Example_02 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }
  }

  //创建ActorSystem对象
  val system = ActorSystem("MyActorSystem")
  //返回ActorSystem的LoggingAdpater
  val systemLog=system.log
  //创建MyActor，指定actor名称为myactor
  val myactor = system.actorOf(Props[MyActor], name = "myactor")

  systemLog.info("准备向myactor发送消息")
  //向myactor发送消息
  myactor!"test"
  myactor! 123

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

代码运行结果：

[INFO] [04/02/2016 09:39:21.088] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 09:39:21.089] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/myactor] received test
[INFO] [04/02/2016 09:39:21.089] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/myactor] received unknown message

代码原理与Example_01类似，这里不再赘述。

2. 创建Actor

在前面两个例子中，通过

val myactor = system.actorOf(Props[MyActor], name = "myactor")

创建Actor，需要注意的是system.actorOf方法返回的是ActorRef对象，ActorRef为Actor的引用，使用ActorRef对象可以进行消息的发送等操作。Props为配置对象，在创建Actor时使用，它是不可变的对象，因此它是线程案例且完全可共享的。Akka中创建Actor时，也允许直接传入MyActor对象的引用，例如

//直接通过new MyActor的方式传入MyActor对象的引用，注意这里是Props(new MyActor)
val myactor = system.actorOf(Props(new MyActor), name = "myactor")

但是Akka不推荐这么做，官方文档给出的解释是这种方式会导致不可序列化的Props对象且可能会导致竞争条件（破坏Actor的封装性）。另外需要特别注意的是，不允许通过下列代码创建Actor

//下列两行代码编译可以通过，但运行时出抛出异常
  val  myActor=new MyActor
  val myactor = system.actorOf(Props(myActor), name = "myactor")

完整运行代码如下：

/*
 *创建Actor
 */
object Example_03 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test")
      case _      => log.info("received unknown message")
    }
  }

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

  //下列两行代码编译可以通过，但运行时出抛出异常
  val  myActor=new MyActor
  val myactor = system.actorOf(Props(myActor), name = "myactor")

  systemLog.info("准备向myactor发送消息")
  //向myactor发送消息
  myactor!"test"
  myactor! 123

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

运行结果如下：

Exception in thread "main" akka.actor.ActorInitializationException: You cannot create an instance of [chapter02.Example_03$MyActor] explicitly using the constructor (new). You have to use one of the 'actorOf' factory methods to create a new actor. See the documentation.
    at akka.actor.ActorInitializationException$.apply(Actor.scala:167)
    at akka.actor.Actor$class.$init$(Actor.scala:423)
    at chapter02.Example_03$MyActor.<init>(MyActor.scala:73)
    at chapter02.Example_03$delayedInit$body.apply(MyActor.scala:84)
    at scala.Function0$class.apply$mcV$sp(Function0.scala:40)
    at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:12)
    at scala.App$$anonfun$main$1.apply(App.scala:71)
	at scala.App$$anonfun$main$1.apply(App.scala:71)
    at scala.collection.immutable.List.foreach(List.scala:318)
    at scala.collection.generic.TraversableForwarder$class.foreach(TraversableForwarder.scala:32)
    at scala.App$class.main(App.scala:71)
    at chapter02.Example_03$.main(MyActor.scala:68)
    at chapter02.Example_03.main(MyActor.scala)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

从“You cannot create an instance of [chapter02.Example_03$MyActor] explicitly using the constructor (new). You have to use one of the ‘actorOf’ factory methods to create a new actor.”可以看到，不能通过显式地调用构造函数创建Actor，只能使用actorOf工厂方法创建Actor。

下面介绍2种在实际中经常使用的Actor创建方法

（1）调用system.actorOf创建Actor

val system = ActorSystem("mySystem")
val myActor = system.actorOf(Props[MyActor], "myactor2")

完整代码在Example_01、Example_02中已经演示过了，这里需要说明的是通过system.actorOf工厂方法创建的Actor为顶级Actor

这里写图片描述

在Akka框架中，每个Akka应用程序都会有一个守卫Actor，名称为user，所有通过system.actorOf工厂方法创建的Actor都为user的子Actor，也是整个Akka程序的顶级Actor。

（2）调用context.actorOf创建Actor

完整代码如下：

/*
 *创建Actor,调用context.actorOf方法
 */
object Example_04 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props

  class FirstActor extends Actor with ActorLogging{
    //通过context.actorOf方法创建Actor
    val child = context.actorOf(Props[MyActor], name = "myChild")
    def receive = {
      case x => child ! x;log.info("received "+x)
    }

  }

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test")
      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 15:05:34.770] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 15:05:34.771] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor/myChild] received test
[INFO] [04/02/2016 15:05:34.771] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 15:05:34.771] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 15:05:34.771] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor/myChild] received unknown message

通过代码的运行结果可以看到，FirstActor的Actor路径信息为akka://MyActorSystem/user/firstActor，而通过

class FirstActor extends Actor with ActorLogging{
    //通过context.actorOf方法创建Actor
    val child = context.actorOf(Props[MyActor], name = "myChild")
    def receive = {
      case x => child ! x;log.info("received "+x)
    }

  }

代码使用context.actorOf创建的MyActor，其Actor路径信息为[akka://MyActorSystem/user/firstActor/myChild]，这意味着mychild为firstActor的子Actor，层次结构如下图所示

这里写图片描述

也就是说context.actorOf和system.actorOf的差别是system.actorOf创建的actor为顶级Actor，而context.actorOf方法创建的actor为调用该方法的Actor的子Actor

3. 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

在代码中分别对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

代码中使用

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”

（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容错部分进行讲解。

4. Actor引用、Actor路径

下图是Akka官方文档中给出的一张图

这里写图片描述

该图清晰地说明了ActorPath，ActorRef，Actor及ActorSystem之间的关系，并说明了Actor整体的层次结构。前面我们提到，Akka应用程序会持有一个名称为user的Actor，该Actor被称为guardian supervisor（守卫监督器），无论是ActorSystem创建的Actor还是通过ActorContext创建的Actor都为user的子类，它是最顶级的Actor。

（一）ActorRef

对于ActorRef，我们已经很熟悉了，通过调用ActorSystem.actorOf方法可以创建Actor，返回的便是ActorRef，例如代码

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

返回的便是FirstActor的ActorRef对象，ActorRef最重要的作用便是向Actor发送消息，例如

//向myactor发送消息
myactor!"test"
myactor! 123

另外，还可以通过context隐式对象获取父Actor和子Actor的ActorRef，示例代码如下：

/*
*Actor API:成员变量self及sender()方法的使用
*/
object Example_07 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{
    var parentActorRef:ActorRef=_
    override def preStart(): Unit ={
      //通过context.parent获取其父Actor的ActorRef
      parentActorRef=context.parent
    }
    def receive = {
      case "test" => log.info("received test");parentActorRef!"message from ParentActorRef"
      case _      => log.info("received unknown message");
    }

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

  //创建FirstActor对象
  val myactor = system.actorOf(Props[FirstActor], name = "firstActor")
  //获取ActorPath
  val myActorPath=system.child("firstActor")
  //通过system.actorSelection方法获取ActorRef
  val myActor1=system.actorSelection(myActorPath)
  systemLog.info("准备向myactor发送消息")
  //向myActor1发送消息
  myActor1!"test"
  myActor1! 123
  Thread.sleep(5000)
  //关闭ActorSystem，停止程序的运行
  system.shutdown()
}

代码运行结果

[INFO] [04/02/2016 20:28:08.941] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor
[INFO] [04/02/2016 20:28:08.942] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor] received message from ParentActorRef
[INFO] [04/02/2016 20:28:08.943] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message

代码中，使用

//通过context.parent获取其父Actor的ActorRef
      parentActorRef=context.parent

获取MyActor 的直接父Actor的ActorRef，在本例中为FirstActor，因为在FirstActor中，我们使用

//通过context上下文创建Actor
      child = context.actorOf(Props[MyActor], name = "myActor")

创建了MyActor，FirstActor便自动成为MyActor的直接Supervisor。如此便可以通过代码

parentActorRef!"message from ParentActorRef"

发送消息。

另外，还可以通过

//创建FirstActor对象
  val myactor = system.actorOf(Props[FirstActor], name = "firstActor")
  //获取ActorPath
  val myActorPath=system.child("firstActor")
  //通过system.actorSelection方法获取ActorRef
  val myActor1=system.actorSelection(myActorPath)

system.actorSelection(myActorPath)方法获取相应的ActorRef。然后再使用获取到的ActorRef向Actor发送消息

//向myActor1发送消息
  myActor1!"test"
  myActor1! 123

现在，让我们来总结一下获取ActorRef的方法：

  1. 通过ActorSystem的actorOf方法，不过这种方式是通过创建Actor，然后返回其ActorRef
  2. 通过context.actorOf方法，这种方式也是通过创建Actor,然后返回其ActorRef
  3. 通过context.parent、context.self、context.children方法获取当前Actor的父Actor、当前Actor及子Actor的ActorRef，这种方式是获取已经创建好的Actor的ActorRef
  4. 通过val myActor1=system.actorSelection(myActorPath)方法来获取ActorRef，这种方式也是获取已经创建好的Actor的ActorRef
（二）ActorPath

在前面的例子中，我们通过

val myActorPath=system.child("firstActor")

已经使用到了ActorPath。在Akka中，ActorPath采用统一资源定位符的方式进行组织，例如

//本地ActorPath
"akka://my-sys/user/service-a/worker1" 
//远程ActorPath
"akka.tcp://my-sys@host.example.com:5678/user/service-b"

本地ActorPath是Akka并发编程中的ActorPath表示方式，而远程ActorPath是Akka分布式编程中常用的ActorPath表示方式，”akka.tcp://my-sys@host.example.com:5678/user/service-b”中的TCP表示使用的是TCP协议，也可以使用UPD协议，使用UDP协议的远程ActorPath表示方式有如下形式

"akka.udp://my-sys@host.example.com:5678/user/service-b"

ActorPath当中，akka.udp表示的是使用的协议，my-sys表示的是ActorSytem名称，host.example.com:5678为远程机器地址及端口，user为guardian supervisor，service-b为当前应用程序的顶级Actor（通过system.actorOf方法创建的）

/*
*ActorPath
*/
object Example_08 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{
    def receive = {
      case "test" => log.info("received test");
      case _      => log.info("received unknown message");
    }

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

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

  //获取ActorPath
  val firstActorPath=system.child("firstActor")
  systemLog.info("firstActorPath--->{}",firstActorPath)

  //通过system.actorSelection方法获取ActorRef
  val myActor1=system.actorSelection(firstActorPath)

  //直接指定其路径
  val myActor2=system.actorSelection("/user/firstActor")
  //使用相对路径
  val myActor3=system.actorSelection("../firstActor")

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

代码运行结果：

[INFO] [04/02/2016 21:04:59.612] [main] [ActorSystem(MyActorSystem)] firstActorPath--->akka://MyActorSystem/user/firstActor
[INFO] [04/02/2016 21:04:59.612] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor
[INFO] [04/02/2016 21:04:59.615] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 21:04:59.616] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 21:04:59.616] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 21:04:59.616] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 21:04:59.616] [MyActorSystem-akka.actor.default-dispatcher-3] [akka://MyActorSystem/user/firstActor/myActor] received unknown message

本例中的重点代码如下

//获取ActorPath
  val firstActorPath=system.child("firstActor")
  systemLog.info("myActorPath--->{}",firstActorPath)

  //通过system.actorSelection方法获取ActorRef
  val myActor1=system.actorSelection(firstActorPath)

  //直接指定其路径
  val myActor2=system.actorSelection("/user/firstActor")
  //使用相对路径
  val myActor3=system.actorSelection("../firstActor")

通过 val firstActorPath=system.child(“firstActor”)构造一个ActorPath，然后使用

val myActor1=system.actorSelection(firstActorPath)

获取路径下的ActorRef，除这种方式外，还可以通过绝对路径 val myActor2=system.actorSelection(“/user/firstActor”)及相对路径 val myActor3=system.actorSelection(“../firstActor”)的方式获取ActorRef，需要注意的是绝对路径使用的是guardian supevisor，即/user/firstActor的这种方式。

如果要获取myActor，则获取方法是类似的，例如

//获取ActorPath
val myActorPath=system.child("firstActor").child("myActor")
systemLog.info("firstActorPath--->{}",myActorPath)

//通过system.actorSelection方法获取ActorRef
val myActor1=system.actorSelection(myActorPath)

//直接指定其路径
val myActor2=system.actorSelection("/user/firstActor/myActor")
//使用相对路径
val myActor3=system.actorSelection("../firstActor/myActor")

完整代码如下：

/*
*ActorPath，获取myActor
*/
object Example_09 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{
    def receive = {
      case "test" => log.info("received test");
      case _      => log.info("received unknown message");
    }

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

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

  //获取ActorPath
  val myActorPath=system.child("firstActor").child("myActor")
  systemLog.info("firstActorPath--->{}",myActorPath)

  //通过system.actorSelection方法获取ActorRef
  val myActor1=system.actorSelection(myActorPath)

  //直接指定其路径
  val myActor2=system.actorSelection("/user/firstActor/myActor")
  //使用相对路径
  val myActor3=system.actorSelection("../firstActor/myActor")

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

代码运行结果：

[INFO] [04/02/2016 21:21:14.377] [main] [ActorSystem(MyActorSystem)] firstActorPath--->akka://MyActorSystem/user/firstActor/myActor
[INFO] [04/02/2016 21:21:14.377] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] preStart() in FirstActor
[INFO] [04/02/2016 21:21:14.381] [main] [ActorSystem(MyActorSystem)] 准备向myactor发送消息
[INFO] [04/02/2016 21:21:14.382] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 21:21:14.382] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message

关于远程ActorRef的获取，我们将在后续章节中进行讲述。

5. 停止Actor

####（1）通过ActorSystem.shutdown方法停止所有 Actor的运行

/*
*停止Actor:ActorSystem.shutdown方法
*/
object Example_10 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props

  class FirstActor extends Actor with ActorLogging{

    var child:ActorRef = context.actorOf(Props[MyActor], name = "myActor")
    def receive = {
      //向MyActor发送消息
      case x => child ! x;log.info("received "+x)
    }
    override def postStop(): Unit = {
      log.info("postStop In FirstActor")
    }
  }

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test");
      case _      => log.info("received unknown message");
    }
    override def postStop(): Unit = {
      log.info("postStop In MyActor")
    }
  }
  val system = ActorSystem("MyActorSystem")
  val systemLog=system.log

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

  systemLog.info("准备向firstactor发送消息")
  //向firstactor发送消息
  firstactor!"test"
  firstactor! 123
  //关闭ActorSystem，停止所有Acotr运行
  system.shutdown()
}

代码运行结果：

[INFO] [04/02/2016 21:51:34.440] [main] [ActorSystem(MyActorSystem)] 准备向firstactor发送消息
[INFO] [04/02/2016 21:51:34.441] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 21:51:34.441] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 21:51:34.441] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 21:51:34.441] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 21:51:34.446] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] postStop In MyActor
[INFO] [04/02/2016 21:51:34.447] [MyActorSystem-akka.actor.default-dispatcher-5] [akka://MyActorSystem/user/firstActor] postStop In FirstActor

####（2）通过context.stop方法停止Actor的运行

/*
*停止Actor:context.stop方法
*/
object Example_11 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props

  class FirstActor extends Actor with ActorLogging{

    var child:ActorRef = context.actorOf(Props[MyActor], name = "myActor")
    def receive = {
      case "stop"=>context.stop(child)
      case x =>{
        //向MyActor发送消息
        child ! x
        log.info("received "+x)
      }

    }
    override def postStop(): Unit = {
      log.info("postStop In FirstActor")
    }
  }

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test");
      case _      => log.info("received unknown message");
    }
    override def postStop(): Unit = {
      log.info("postStop In MyActor")
    }
  }
  val system = ActorSystem("MyActorSystem")
  val systemLog=system.log

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

  systemLog.info("准备向firstactor发送消息")
  //向firstactor发送消息
  firstactor!"test"
  firstactor! 123
  firstactor!"stop"

}

代码运行结果：

[INFO] [04/02/2016 22:02:48.760] [main] [ActorSystem(MyActorSystem)] 准备向firstactor发送消息
[INFO] [04/02/2016 22:02:48.761] [MyActorSystem-akka.actor.default-dispatcher-5] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 22:02:48.761] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 22:02:48.762] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 22:02:48.762] [MyActorSystem-akka.actor.default-dispatcher-5] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 22:02:48.763] [MyActorSystem-akka.actor.default-dispatcher-5] [akka://MyActorSystem/user/firstActor/myActor] postStop In MyActor

代码的重点为case “stop”=>context.stop(child)，直接通过context.stop方法停止Actor的运行。注意程序中并没有使用system.shutdown方法，因此整个程序不会停止。

####（3）通过akka.actor.PoisonPill消息停止Actor的运行

/*
*停止Actor:使用akka.actor.PoisonPill
*/
object Example_12 extends App{
  import akka.actor.Actor
  import akka.actor.ActorSystem
  import akka.actor.Props
  import akka.actor.PoisonPill

  class FirstActor extends Actor with ActorLogging{

    var child:ActorRef = context.actorOf(Props[MyActor], name = "myActor")
    def receive = {
      //向child发送PoisonPill停止其运行
      case "stop"=>child!PoisonPill
      case x =>{
        //向MyActor发送消息
        child ! x
        log.info("received "+x)
      }

    }
    override def postStop(): Unit = {
      log.info("postStop In FirstActor")
    }
  }

  class MyActor extends Actor with ActorLogging{
    def receive = {
      case "test" => log.info("received test");
      case _      => log.info("received unknown message");
    }
    override def postStop(): Unit = {
      log.info("postStop In MyActor")
    }
  }
  val system = ActorSystem("MyActorSystem")
  val systemLog=system.log

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

  systemLog.info("准备向firstactor发送消息")
  //向firstactor发送消息
  firstactor!"test"
  firstactor! 123
  firstactor!"stop"

}

代码运行结果：

[INFO] [04/02/2016 22:12:09.947] [main] [ActorSystem(MyActorSystem)] 准备向firstactor发送消息
[INFO] [04/02/2016 22:12:09.947] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myActor] received test
[INFO] [04/02/2016 22:12:09.947] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received test
[INFO] [04/02/2016 22:12:09.947] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor] received 123
[INFO] [04/02/2016 22:12:09.947] [MyActorSystem-akka.actor.default-dispatcher-2] [akka://MyActorSystem/user/firstActor/myActor] received unknown message
[INFO] [04/02/2016 22:12:09.951] [MyActorSystem-akka.actor.default-dispatcher-4] [akka://MyActorSystem/user/firstActor/myActor] postStop In MyActor

代码与Exampel_11中的不同之处在于

//向child发送PoisonPill停止其运行
case "stop"=>child!PoisonPill

它使用不是context.stop方法，而是向MyActor发送了PoisonPill消息，其它代码不变。

还有一种gracefulStop方法可以停止Actor的运行，这部分内容等了解完Future类的作用原理之后再来讨论。

6. 消息发送

Akka提供了两种消息模型：fire-and-forget和Send-And-Receive-Future。

fire-and-forget是一种单向消息发送模型，指的是异步发送消息，通过异步发送消息且消息发送后可以立即返回，Akka中使用!方法进行fire-and-forget消息发送，如stringActor!”Creating Actors with implicit val context”，它的意思是当前发送方Actor向stringActor发送字符串消息”Creating Actors with implicit val context”，发送完该消息后立即返回，而无需等待stringActor的返回，!还有个重载的方法tell；

Send-And-Receive-Future是一种双向消息发送模型，指的是异步发送消息，向目标Actor发送完消息后，然后返回一个Future作为后期可能的返回，当前发送方Actor将等待目标Actor的返回，Akka中使用?方法进行Send-And-Receive-Future消息的发送，它也同样有一个重载的方法ask

1. !消息发送，Fire-and-Forget消息模型
/**
  * 消息处理：!(Fire-Forget)
  */
object Example12 extends  App{
  import akka.actor.Actor
  import akka.actor.Props
  import akka.event.Logging
  import akka.actor.ActorSystem

 //定义几种不同的消息
  case class Start(var msg:String)
  case class Run(var msg:String)
  case class Stop(var msg:String)

  class ExampleActor extends Actor {
    val other = context.actorOf(Props[OtherActor], "OtherActor")
    val log = Logging(context.system, this)
    def receive={
      //使用fire-and-forget消息模型向OtherActor发送消息，隐式地传递sender
      case Start(msg) => other ! msg
      //使用fire-and-forget消息模型向OtherActor发送消息，直接调用tell方法，显式指定sender
      case Run(msg) => other.tell(msg, sender)
    }
  }

  class OtherActor extends  Actor{
    val log = Logging(context.system, this)
    def receive ={
      case s:String=>log.info("received message:\n"+s)
      case _      ⇒ log.info("received unknown message")
    }
  }

  //创建ActorSystem,ActorSystem为创建和查找Actor的入口
  //ActorSystem管理的Actor共享配置信息如分发器(dispatchers)、部署（deployments）等
  val system = ActorSystem("MessageProcessingSystem")

  //创建ContextActor
  val exampleActor = system.actorOf(Props[ExampleActor],name="ExampleActor")

  //使用fire-and-forget消息模型向exampleActor发送消息
  exampleActor!Run("Running")
  exampleActor!Start("Starting")

  //关闭ActorSystem
  system.shutdown()
}

代码运行结果如下：

[INFO] [03/20/2016 20:57:43.665] [MessageProcessingSystem-akka.actor.default-dispatcher-5] [akka://MessageProcessingSystem/user/ExampleActor/OtherActor] received message:
Running
[INFO] [03/20/2016 20:57:43.672] [MessageProcessingSystem-akka.actor.default-dispatcher-5] [akka://MessageProcessingSystem/user/ExampleActor/OtherActor] received message:
Starting

在ExampleActor中，通过隐式变量context创建了OtherActor实例：val other = context.actorOf(Props[OtherActor], “OtherActor”)，在ExampleActor的receive方法中，处理两种不同类型的消息例如：

//使用fire-and-forget消息模型向OtherActor发送消息，隐式地传递sender
  case Start(msg) => other ! msg
  //使用fire-and-forget消息模型向OtherActor发送消息，直接调用tell方法，显式指定sender
  case Run(msg) => other.tell(msg, sender)

处理Start类型的消息时，直接使用!进行消息发送，而处理Run类型的消息时，使用的是tell方法，可以看到使用tell方法需要显式地指定其sender，而使用!进行消息发送则不需要，事实上!方法通过隐式值传入需要的Sender，对比!与tell方法的定义便很容易理解

//!方法的定义
def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit
//tell方法的定义
final def tell(msg: Any, sender: ActorRef): Unit = this.!(msg)(sender)

可以看到，tell方法的实现依赖于!方法。如果在一个Actor当中使用!方法时，例如ExampleActor中使用的other ! msg向OtherActor发送消息，则sender隐式为ExampleActor，如果不是在Actor中使用则默认为Actor.noSender，即sender为null。

2. ？消息发送，Send-And-Receive-Future消息模型

理解了Fire-And-Forget消息模型后，接着对Send-And-Receive-Future消息模型进行介绍，下面的代码给出了其使用示例。

/**
  * 消息处理：?(Send-And-Receive-Future)
  */
object Example13 extends  App{
  import akka.actor.Actor
  import akka.actor.Props
  import akka.event.Logging
  import akka.actor.ActorSystem
  import scala.concurrent.Future
  import akka.pattern.ask
  import akka.util.Timeout
  import scala.concurrent.duration._
  import akka.pattern.pipe
  import scala.concurrent.ExecutionContext.Implicits.global

  //消息：个人基础信息
  case class BasicInfo(id:Int,val name:String, age:Int)
  //消息：个人兴趣信息
  case class InterestInfo(id:Int,val interest:String)
  //消息: 完整个人信息
  case class Person(basicInfo: BasicInfo,interestInfo: InterestInfo)

  //基础信息对应Actor
  class BasicInfoActor extends Actor{
    val log = Logging(context.system, this)
    def receive = {
      //处理送而来的用户ID，然后将结果发送给sender（本例中对应CombineActor）
      case id:Int ⇒log.info("id="+id);sender!new BasicInfo(id,"John",19)
      case _      ⇒ log.info("received unknown message")
    }
  }

  //兴趣爱好对应Actor
  class InterestInfoActor extends Actor{
    val log = Logging(context.system, this)
    def receive = {
      //处理发送而来的用户ID，然后将结果发送给sender（本例中对应CombineActor）
      case id:Int ⇒log.info("id="+id);sender!new InterestInfo(id,"足球")
      case _      ⇒ log.info("received unknown message")
    }
  }

  //Person完整信息对应Actor
  class PersonActor extends Actor{
    val log = Logging(context.system, this)
    def receive = {
      case person: Person =>log.info("Person="+person)
      case _      ⇒ log.info("received unknown message")
    }
  }

  class CombineActor extends Actor{
    implicit val timeout = Timeout(5 seconds)
    val basicInfoActor = context.actorOf(Props[BasicInfoActor],name="BasicInfoActor")
    val interestInfoActor = context.actorOf(Props[InterestInfoActor],name="InterestInfoActor")
    val personActor = context.actorOf(Props[PersonActor],name="PersonActor")
    def receive = {
      case id: Int =>
        val combineResult: Future[Person] =
          for {
            //向basicInfoActor发送Send-And-Receive-Future消息，mapTo方法将返回结果映射为BasicInfo类型
            basicInfo <- ask(basicInfoActor, id).mapTo[BasicInfo]
            //向interestInfoActor发送Send-And-Receive-Future消息，mapTo方法将返回结果映射为InterestInfo类型
            interestInfo <- ask(interestInfoActor, id).mapTo[InterestInfo]
          } yield Person(basicInfo, interestInfo)

        //将Future结果发送给PersonActor
       pipe(combineResult).to(personActor)
    }
  }

  val _system = ActorSystem("Send-And-Receive-Future")
  val combineActor = _system.actorOf(Props[CombineActor],name="CombineActor")
  combineActor ! 12345
  Thread.sleep(5000)
  _system.shutdown

}

代码运行结果如下：

[INFO] [03/20/2016 22:55:11.208] [Send-And-Receive-Future-akka.actor.default-dispatcher-3] [akka://Send-And-Receive-Future/user/CombineActor/BasicInfoActor] id=12345
[INFO] [03/20/2016 22:55:11.220] [Send-And-Receive-Future-akka.actor.default-dispatcher-2] [akka://Send-And-Receive-Future/user/CombineActor/InterestInfoActor] id=12345
[INFO] [03/20/2016 22:55:11.223] [Send-And-Receive-Future-akka.actor.default-dispatcher-4] [akka://Send-And-Receive-Future/user/CombineActor/PersonActor] Person=Person(BasicInfo(12345,John,19),InterestInfo(12345,足球))

代码中定义了3种类型的消息，分别是个人基础信息case class BasicInfo(id:Int,val name:String, age:Int)、个人兴趣信息case class InterestInfo(id:Int,val interest:String)以及完整个人信息case class Person(basicInfo: BasicInfo,interestInfo: InterestInfo)，然后为这3种类型的消息定义了相应的Actor即BasicInfoActor、InterestInfoActor和PersonActor，在CombineActor分别创建相应Actor的实例，receive方法中使用ask向BasicInfoActor、InterestInfoActor发送Send-And-Receive-Future模型消息，BasicInfoActor、InterestInfoActor中的receive方法接收到发送来的Int类型消息并分别使用!向CombineActor发送BasicInfo、InterestInfo消息，将结果保存在Future[Person]中，然后通过代码pipe(combineResult).to(personActor)将结果发送给PersonActor。

三、Type Actor

1. Typed Actor定义

Akka中的Typed Actor是Active Objects设计模式的实现，Active Objects模式将方法的执行和方法的调用进行解耦合，从而为程序引入并发性。Typed Actor由公用的接口和对应实现两部分构成，其后面深层次的实现使用的是代理模式，即通过使用JDK中的动态代理来实现，在调用接口的方法时自动分发到实现接口的对象上。Typed Actor的定义[ ]如下所示。

trait Squarer {
    //fire-and-forget消息
    def squareDontCare(i: Int): Unit
    //非阻塞send-request-reply消息
    def square(i: Int): Future[Int]
    //阻塞式的send-request-reply消息
    def squareNowPlease(i: Int): Option[Int]
    //阻塞式的send-request-reply消息
    def squareNow(i: Int): Int
  }

  class SquarerImpl(val name: String) extends Squarer {
    def this() = this("SquarerImpl")

    def squareDontCare(i: Int): Unit = i * i
    def square(i: Int): Future[Int] = Promise.successful(i * i).future
    def squareNowPlease(i: Int): Option[Int] = Some(i * i)
    def squareNow(i: Int): Int = i * i
  }

2. 创建Typed Actor

通过下列代码创建Typed Actor实例。

//直接通过默认的构造函数创建Typed Actor
val mySquarer: Squarer =TypedActor(system).typedActorOf(TypedProps[SquarerImpl]())
//直接通过默认的构造函数创建Typed Actor并指定Typed Actor名称
val mySquarer: Squarer =TypedActor(system).typedActorOf(TypedProps[SquarerImpl](),"mySquarer")
//通过非默认的构造函数创建Typed Actor并指定Typed Actor名称
val otherSquarer: Squarer = TypedActor(system).typedActorOf(TypedProps(classOf[Squarer],new SquarerImpl("SquarerImpl")), "otherSquarer")

上面代码演示的是使用构造函数和非默认构造函数创建Typed Actor，其中Squarer为代理的类型，SquarerImpl为具体实现的类型。

3. 消息发送

//fire-forget消息发送
mySquarer.squareDontCare(10)

//send-request-reply消息发送
val oSquare = mySquarer.squareNowPlease(10)

val iSquare = mySquarer.squareNow(10)

//Request-reply-with-future 消息发送
val fSquare = mySquarer.square(10)
val result = Await.result(fSquare, 5 second)

代码mySquarer.squareDontCare(10)是单向消息发送，方法将在另外一个线程上异步地执行；val oSquare = mySquarer.squareNowPlease(10)、val iSquare = mySquarer.squareNow(10)为Request-reply消息发送，在特定时间内以阻塞的方式执行，对于squareNowPlease(10)方法如果在对应时间内没有返回结果则返回值为None，否则返回值为Option[Int]类型，对于squareNow(10)方法如果在对应时间内无返回值则会抛出异常java.util.concurrent.TimeoutException，否则返回Int类型值；val fSquare = mySquarer.square(10)为Request-reply-with-future式的消息发送，以非阻塞的方式执行，可以通过val result = Await.result(fSquare, 5 second)获取执行结果。完整代码如下所示。

/*
 * Typed Actor
 */
object Example_01 extends  App {

  import akka.event.Logging
  import scala.concurrent.{ Promise, Future }
  import akka.actor.{ TypedActor, TypedProps }
  import scala.concurrent.duration._

  trait Squarer {
    //fire-and-forget消息
    def squareDontCare(i: Int): Unit
    //非阻塞send-request-reply消息
    def square(i: Int): Future[Int]
    //阻塞式的send-request-reply消息
    def squareNowPlease(i: Int): Option[Int]
    //阻塞式的send-request-reply消息
    def squareNow(i: Int): Int
  }

  class SquarerImpl(val name: String) extends Squarer {
    def this() = this("SquarerImpl")

    def squareDontCare(i: Int): Unit = i * i
    def square(i: Int): Future[Int] = Promise.successful(i * i).future
    def squareNowPlease(i: Int): Option[Int] = Some(i * i)
    def squareNow(i: Int): Int = i * i
  }

  val system = ActorSystem("TypedActorSystem")
  val log = Logging(system, this.getClass)

  //使用默认构造函数创建Typed Actor
  val mySquarer: Squarer =
    TypedActor(system).typedActorOf(TypedProps[SquarerImpl](),"mySquarer")

  //使用非默认构造函数创建Typed Actor
    val otherSquarer: Squarer =
      TypedActor(system).typedActorOf(TypedProps(classOf[Squarer],
        new SquarerImpl("SquarerImpl")), "otherSquarer")

  //fire-forget消息发送
  mySquarer.squareDontCare(10)

  //send-request-reply消息发送
  val oSquare = mySquarer.squareNowPlease(10)

  log.info("oSquare="+oSquare)

  val iSquare = mySquarer.squareNow(10)
  log.info("iSquare="+iSquare)

  //Request-reply-with-future 消息发送
  val fSquare = mySquarer.square(10)
  val result = Await.result(fSquare, 5 second)

  log.info("fSquare="+result)

  system.shutdown()
}

代码运行结果如下：

[INFO] [03/21/2016 21:15:50.592] [main] [Example12_9(akka://TypedActorSystem)]oSquare=Some(100)[INFO][03/21/201621:15:50.649][main][Example129(akka://TypedActorSystem)] iSquare=100   
[INFO] [03/21/2016 21:15:50.649] [main] [Example12_9$(akka://TypedActorSystem)] fSquare=100

4. 停止运行Typed Actor

当Typed Actor不再需要时要将其停止，有3种方法停止Typed Actor的运行：

  1. 通过system.shutdown()停止ActorSystem中所有的Typed Actor；
  2. 调用TypedActor(system).stop(mySquarer)停止指定的Typed Actor；
  3. 调用TypedActor(system).poisonPill(otherSquarer)停止指定的Typed Actor。

具体使用代码如下：

/*
 * 停止Typed Actor
 */
object Example_3 extends  App {

  import akka.event.Logging
  import scala.concurrent.{ Promise, Future }
  import akka.actor.{ TypedActor, TypedProps }
  import scala.concurrent.duration._

  trait Squarer {
    //fire-and-forget消息
    def squareDontCare(i: Int): Unit
    //非阻塞send-request-reply消息
    def square(i: Int): Future[Int]
    //阻塞式的send-request-reply消息
    def squareNowPlease(i: Int): Option[Int]
    //阻塞式的send-request-reply消息
    def squareNow(i: Int): Int
  }

  //混入PostStop和PreStart
  class SquarerImpl(val name: String) extends  Squarer with PostStop with PreStart {
    import TypedActor.context
    val log = Logging(context.system,TypedActor.self.getClass())
    def this() = this("SquarerImpl")

    def squareDontCare(i: Int): Unit = i * i
    def square(i: Int): Future[Int] = Promise.successful(i * i).future
    def squareNowPlease(i: Int): Option[Int] = Some(i * i)
    def squareNow(i: Int): Int = i * i

    def postStop(): Unit={
      log.info ("TypedActor Stopped")
    }
    def preStart(): Unit={
      log.info ("TypedActor  Started")
    }
  }

  val system = ActorSystem("TypedActorSystem")
  val log = Logging(system, this.getClass)

  //使用默认构造函数创建Typed Actor
  val mySquarer: Squarer =
    TypedActor(system).typedActorOf(TypedProps[SquarerImpl](),"mySquarer")

  //使用非默认构造函数创建Typed Actor
  val otherSquarer: Squarer =
    TypedActor(system).typedActorOf(TypedProps(classOf[Squarer],
      new SquarerImpl("SquarerImpl")), "otherSquarer")

  //Request-reply-with-future 消息发送
  val fSquare = mySquarer.square(10)
  val result = Await.result(fSquare, 5 second)
  log.info("fSquare="+result)

  //调用poisonPill方法停止Actor运行
  TypedActor(system).poisonPill(otherSquarer)

  //调用stop方法停止Actor运行
  TypedActor(system).stop(mySquarer)

  //system.shutdown()
}

代码运行结果如下所示。

[INFO] [03/21/2016 22:41:51.119] [TypedActorSystem-akka.actor.default-dispatcher-2] [$Proxy0(akka://TypedActorSystem)] TypedActor  Started
[INFO] [03/21/2016 22:41:51.123] [TypedActorSystem-akka.actor.default-dispatcher-2] [$Proxy1(akka://TypedActorSystem)] TypedActor  Started
[INFO] [03/21/2016 22:41:51.124] [main] [Example12_10$(akka://TypedActorSystem)] fSquare=100
[INFO] [03/21/2016 22:41:51.131] [TypedActorSystem-akka.actor.default-dispatcher-5] [$Proxy1(akka://TypedActorSystem)] TypedActor Stopped
[INFO] [03/21/2016 22:41:51.131] [TypedActorSystem-akka.actor.default-dispatcher-3] [$Proxy0(akka://TypedActorSystem)] TypedActor Stopped

代码中类SquarerImpl 混入了PreStart和PostStop两个trait：class SquarerImpl(val name: String) extends Squarer with PostStop with PreStart，这样的话在创建TypedActor之前和停止TypedActor后能够进行相应的操作，本例中主要是为监视TypedActor的创建和停止过程。代码TypedActor(system).stop(mySquarer)通过stop方法停止TypedActor，而TypedActor(system).poisonPill(otherSquarer)通过调用poisonPill方法停止运行TypedActor。

Fighting_No1
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】分布式计算和通信框架（AKKA）入门介绍
本本本添哥
03-20 4501
Actor模型是一种并发编程模型，它将计算机系统中的并发实体抽象为Actor，每个Actor都是一个独立的计算单元，它们之间通过消息传递进行通信。Actor之间的通信是异步的，无需共享内存，因此可以避免共享内存带来的并发问题。Actor模型可以轻松地编写出高并发、分布式、可容错的应用程序，因此被广泛应用于分布式系统和并发编程领域。
Akka原理与代码实例讲解
最新发布
禅与计算机程序设计艺术
05-31 689
Akka原理与代码实例讲解 1.背景介绍 1.1 什么是Akka Akka是一个用于构建高度并发、分布式和容错应用程序的开源工具包和运行时。它基于Actor模型构建,并使用Scala和Java编写。Actor模型是一种将应用程序设计为由许多独立执行
横向扩展——集群化
LYX_WIN
07-04 3174
1.集群的定义集群就是一组可以互相通信的服务器。集群中的每台服务器成为一个节点或成员。 集群可以动态修改大小，并且在发生错误情况时继续运行，把影响降到最低。所以集群 需要具备两个功能:失败发现以及使得集群中的所有成员最终能够提供一致的视图。2.在 Akka Cluster 中，每个节点监控的最大节点数默认是 5 个节点。在 Akka 中，失败检测是通过在节点间发送心跳消息并接收响应来完成的。这种最...
强力推荐：AsyncAwaitBestPractices - 让异步编程更安全、高效
gitblog_00072的博客
05-13 379
强力推荐：AsyncAwaitBestPractices - 让异步编程更安全、高效 项目地址:https://gitcode.com/brminnick/AsyncAwaitBestPractices 在现代软件开发中，异步编程是不可或缺的一部分，而AsyncAwaitBestPractices库则提供了最佳实践，帮助开发者编写出更加可靠和高效的代码。这个库包含了System.Threading...
异步编程 - 14 异步、分布式、基于消息驱动的框架 Akka
小工匠
09-16 6056
Akka 是一个开源的并发、分布式、基于消息驱动的框架，用于构建高可伸缩性、可靠性和并发性强的应用程序。它是基于 JVM（Java虚拟机）的，主要使用 Scala 编程语言开发，但也提供了 Java API，因此可以在 Java 和 Scala 中使用。Actor 模型：Akka 的核心构建块是 Actor，它是一种轻量级并发原语。Actor 之间通过消息通信进行互动，每个 Actor 都有自己的状态和行为，它们之间是相互隔离的，这有助于构建高度可伸缩的系统。并发性和并行性。
akka入门系列-0. 概述
xlchen123456的博客
09-28 2572
0. 概述 本节类似图书里的前言，旨在说明这一系列文章的写作目的、目标读者等内容。 写作目的 本系列写作的最主要目的是用输出倒逼输入，协助自己理清思路，分享是其次的。 由于最近的项目里使用到了akka框架，整个过程处于摸索阶段，遇到了不少雷和坑，排雷填坑的过程，阅读了官方文档，也在网上找过资料。发现了一些问题： 网上的资料：文章理论太多，并且大部分是来自官方文档的搬运，并且很多文章太旧了，是基于classic版本，而akka最新的typed版本在理念和用法上已经是完全不同的了。 官方文档：官方文档是
akka框架，应用于scala
04-03
Akka框架是基于Java虚拟机（JVM）平台的一个强大工具，它专为构建高可用性、高并发和分布式系统而设计。Akka的核心理念是利用actor模型来处理并发问题，提供了一种简单而高效的方式来管理复杂的并发状态，从而避免了...
c#分布式框架akka范例
07-04
Akka.NET是一个强大的工具包，它为.NET开发者提供了一种实现高性能、高可扩展性和容错性的分布式计算的途径。...通过学习和实践这些范例，你将能够更好地理解如何利用Actor模型和.NET框架来解决分布式计算中的挑战。
Flower框架学习和设计模式
02-24
Flower是一个构建在Akka上的反应式微服务框架，开发者只需要针对每一个细粒度的业务功能开发一个Service服务，并将这些Service按照业务流程进行可视化编排，即可得到一个反应式系统。Flower实现异步的基础是AKKA的...
akka_notes:Akka在学习AkkaReact框架的同时注意
05-13
Akka笔记 Akka消息 文档 源代码 从 Akka记录 文档 源代码 从 Akka测试 文档 源代码 从 Akka消息传递请求和响应 文档 源代码 从arunma / AkkaMessagingRequestResponse分叉
Akka框架
hellozhxy的博客
09-16 4572
1. 重要概念 2. Actor模型 3. Akka架构简介 多核处理器的出现使并发编程（Concurrent Programming）成为开发人员必备的一项技能，许多现代编程语言都致力于解决并发编程问题。并发编程虽然能够提高程序的性能，但传统并发编程的共享内存通信机制对开发人员的编程技能要求很高，需要开发人员通过自身的专业编程技能去避免死锁、互斥等待及竞争条件（Race Condition）等，熟悉Java语言并发编程的读者们对这些问题的理解会比较深刻，这些问题使得并发编程比顺序编程要困难得多。 Sca
Akka入门
bao2901203013的专栏
04-06 1587
Akka是一个异步非阻塞高并发处理框架，它是一系列框架，包括akka-actor, akka-remote, akka-cluster, akka-stream等，分别具有高并发处理模型——actor模型，远程通信，集群管理，流处理等功能。
分布式应用框架：Akka学习记录
Gavin_ke的博客
04-01 485
事件可以由日志中的消息流重新生成，以便从过去的状态中重建Actor的状态。使用Event Sourcing的好处是可以实现最终一致性，因为在重播事件日志期间，系统的状态是通过执行事件的历史记录而推导出来的，而不是通过直接查询内存中的状态获得的。其中，基于事件日志的模式是推荐的模式，因为它提供了更好的性能和可伸缩性，并允许Actor以非常高的速率进行状态更新。在Akka中，所有的工作都由Actor执行，每个Actor都是一个独立的计算单元，可以接收和处理消息，也可以发送消息给其他Actor。
Akka入门学习
qq_56224861的博客
08-15 469
akka基础学习 Akka是用Scala创建的，但由于Scala和Java一样，都是java虚拟机上的语言，本质上说，两者并没有什么不同，因此，我们也可以在Java中使用Akka。我们知道，写出一个正确的、高性能并且可扩展的并发程序是相当困难的，那么是否有一个好的框架可以帮助我们轻松构建这么一个应用呢？这就是Akka。 Akka的好处 首先，Akka提供了一种名为Actor的并发模型，其粒度比线程小，这意味着可以在系统中启用大量的Acotr。 其次，Akka中提供了一套容错机制，允许在Acotr出现异
Akka 进阶（一）Dispatcher调度器
长安不及十里的博客
12-23 3586
当前疫情情况下，快递小哥短缺，由于每个快递小哥都有大量的货要送，所以很可能会造成延迟送货，为了解决这个问题，快递公司可能会从两方面入手。让快递小哥们提高单次送货速度，尽可能多送货。临时增派人手，以便处理更多的送货任务。在Akka中，Actor运行在一个线程池之上，每个线程（快递小哥）会处理多个Actor消息（商品），为了能保证Actor消息处理的及时性和线程的使用效率，我们需要对线程池做一些调配或协调的工作，这就是Dispatcher的意义。
Akka框架基本要点介绍
好读书，每有会意，便欣然忘食。
09-12 1780
Akka基于Actor模型，提供了一个用于构建可扩展的（Scalable）、弹性的（Resilient）、快速响应的（Responsive）应用程序的平台。本文基本上是基于Akka的官方文档（版本是2.3.12），通过自己的理解，来阐述Akka提供的一些组件或概念，另外总结了Akka的一些使用场景。 Actor 维基百科这样定义Actor模型： 在计算科学领域，Actor模型
《Java高并发程序设计》学习 --7.5 Akka之选择Actor
sunhaoning的专栏
04-08 1756
Akka提供了一个ActorSelection类，用来批量进行消息发送，示意代码如下： for(int i=0; i<WORDER_COUNT; i++) { workers.add(system.actorOf(Props.create(MyWorker.class,i), "worker_" + i)); } ActorSelection selection = getContext().
ScalaAKKA和Netty通信框架
互联网知识分享
08-10 376
1.1概述ScalaAKKA是一个用于构建高并发、分布式、可扩展应用的开源工具包。它基于Scala编程语言和Actor模型，并提供了一组高级抽象和易于使用的API，使开发者能够轻松地编写可靠、高性能的并发应用程序。1.2 Actor模型Actor模型是一种并发计算模型，它将计算单元称为"actor"，这些actor通过异步消息传递进行通信。actor之间是完全隔离的，它们之间的通信是通过消息传递进行的。每个actor。
Scala框架Akka学习
Maverick_曲流觞的博客
04-09 900
Scala框架Akka,Akka与Scala.actors.Actor的关系,如何创建Actor,Actor中一些重要的生命周期方法,akka的架构原理,介绍ActorSystem,actorOf方法,props,创建Actor的注意事项,Actor的path路径,Akka发送消息/接收消息,!发送异步消息，没有返回值,!?发送同步消息，等待返回值,转发收到的消息给另一个Actor，保持原始发送者不变,Actor定时任务,schedule()方法的格式,利用Akka实现简单多机交互
Akka 2.0 深入学习： Actor Systems与并发控制
"Akka 2.0 文档是一份针对Akka框架的详细技术文档，旨在帮助开发者理解和使用Akka 2.0版本。这份文档由Typesafe Inc于2012年3月8日发布，包含了从基础概念到高级特性的全面介绍，适合学习和参考。" Akka是一个基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值