Akka了解
概念Akka是编译Java和scala开发的高并发、分布式、弹性的消息驱动应用程序的工具。
一个工具为什么能通过编译实现高并发、分布式？
1）使用actor和stream使得编译的系统能做简单并发和分布式系统。
2）可恢复性。使用了reactive模型，具有对错误自愈功能。
3）高性能。支持5000万消息/秒单机并发。较小的内存脚印，每GB能记录250万actors。
4）可伸缩性和去中心化。通过负载均衡路由到合适的工作节点。使用CQRS架构是的集群分片处理。使用CRDT解决最终一致性算法。
5）反应器（reactive）的流数据处理。采用异步非阻塞模型实现。
怎么使用
官方一个简单示例，地址：Get Started with Lightbend Technologies
http://pic3.zhimg.com/v2-408b5b5f5253a3d9c849755fbe1e12ba_r.jpg
点击下载，使用Idea打开。我使用的scala版本的，也可以选择java版本。
下面是示例的代码：
//#full-example
package com.example
import akka.actor.{ Actor, ActorLogging, ActorRef, ActorSystem, Props }
//#greeter-companion
//#greeter-messages
object Greeter {
//#greeter-messages
def props(message: String, printerActor: ActorRef): Props = Props(new Greeter(message, printerActor))
//#greeter-messages
final case class WhoToGreet(who: String)
case object Greet
}
//#greeter-messages
//#greeter-companion
//#greeter-actor
class Greeter(message: String, printerActor: ActorRef) extends Actor {
import Greeter._
import Printer._
var greeting = ""
def receive = {
case WhoToGreet(who) =>
greeting = message + ", " + who
case Greet =>
//#greeter-send-message
printerActor ! Greeting(greeting)
//#greeter-send-message
}
}
//#greeter-actor
//#printer-companion
//#printer-messages
object Printer {
//#printer-messages
def props: Props = Props
//#printer-messages
final case class Greeting(greeting: String)
}
//#printer-messages
//#printer-companion
//#printer-actor
class Printer extends Actor with ActorLogging {
import Printer._
def receive = {
case Greeting(greeting) =>
log.info("Greeting received (from " + sender() + "): " + greeting)
}
}
//#printer-actor
//#main-class
object AkkaQuickstart extends App {
import Greeter._
// Create the 'helloAkka' actor system
val system: ActorSystem = ActorSystem("helloAkka")
//#create-actors
// Create the printer actor
val printer: ActorRef = system.actorOf(Printer.props, "printerActor")
// Create the 'greeter' actors
val howdyGreeter: ActorRef =
system.actorOf(Greeter.props("Howdy", printer), "howdyGreeter")
val helloGreeter: ActorRef =
system.actorOf(Greeter.props("Hello", printer), "helloGreeter")
val goodDayGreeter: ActorRef =
system.actorOf(Greeter.props("Good day", printer), "goodDayGreeter")
//#create-actors
//#main-send-messages
howdyGreeter ! WhoToGreet("Akka")
howdyGreeter ! Greet
howdyGreeter ! WhoToGreet("Lightbend")
howdyGreeter ! Greet
helloGreeter ! WhoToGreet("Scala")
helloGreeter ! Greet
goodDayGreeter ! WhoToGreet("Play")
goodDayGreeter ! Greet
//#main-send-messages
}
//#main-class
//#full-example
运行结果：
Greeting received (from Actor): Hello, Scala
Greeting received (from Actor): Howdy, Akka
Greeting received (from Actor): Good day, Play
Greeting received (from Actor): Howdy, Lightbend
上面结果表示：程序是并发运行的。如最后一行goodDayGreeter ! WhoToGreet("Play")在结果中是第二行就已经执行。
总结
上面从表象上已经大概能了解Akka是做什么事情的了。通过Akka提供的Api并且合理的使用它就可以简单的实现分布式、高性能的Java或者scala程序了。
如果需要深入对其工作原理进行了解，需要研究actor运作机制，后面有时间再学习。
页:
[1]