跟连乐一起学Scala-Actor

1. 每个actor都要扩展Actor类并提供act方法；
2. 要网actor发送消息，可以使用actor ! message
3. 消息发送时异步的，“发完就忘”
4. 要接收消息，actor可以调用receive或react,通常是在循环中这样做
5. receive/react 的参数是由case语句组成的代码块
6. 不同的actor之间不应该共享状态。总是使用消息来发送数据。
7. 不要直接调用actor的方法。通过消息进行通信。
8. 避免同步消息–也就是说将发送消息和等待响应分开。
9. 不同actor可以通过react而不是receive来共享线程，前提是消息处理器的控制流转足够简单。
10. 让actor挂掉是OK的，前提是你有其他actor监控着actor的生死。用链接来设置监控关系。

创建和启动Actor

import scala.actor.Actor

class HiActor extends Actor {
    def act (){
        while (true) {
            receive {
                case "Hi" => println("Hello")

            }
        }
    }
}

val actor1 = new HiActor
actor1.start()

如果需要临时创建一个actor而不是定义一个类，Actor伴生对象带有一个actor方法来创建和启动actor:

import scala.actors.Actor._

val actor2 = actor {
    whhile(true) {
        receive {
        case "Hi" => print("hello)
        }
    }
}

使用actor定义的!操作符。

actor1 ! "Hi"

使用case接收对象。

当运算被分拆到不同actor来并行处理问题的各个部分时，这些处理结果需要被收集到一起。

设计选择如下：

1. 可以有一个全局的actor。

2. actor可以构造成带有指向一个或更多actor的引用。

3. actor可以接收带有指向另一个actor的引用的消息。在请求中提供一个actor引用是常见的做法，比如：actor ! Compute(data, continuation)

4. actor可以返回消息给发送方。receive方法会把sender字段设为当前消息的发送发。

消息通道是类型安全的–你只能接受或发送某个特定类型的消息。

你不会不小心通过消息通道调用某个actor的方法。

消息通道可以是一个OutputChannel(带有!方法)，也可以是一个InputChannel(带有receive或react方法)。Channel类同时扩展OutputChannel和InputChannel特质。

val chnnel = new Channel [Int] (someActor)

case class Compute(input: Seq[Int], result: OutputChannel[Int])

class Conputer extends Actor {
    public void act (){
        while (true){
            receive {
                case Compute(input, out) => (val answer = ...; out ! answer)
            }
        }
    }
}

actor {
    val channel = new Channel[Int]
    val computeActor: Computer = ...
    val input: Seq[Double] = ...
    computeActor ! Compute(input, channel)
    channel.receive {
        case x => ...//我们已知x是一个int
    }

}

actor可以发送一个消息并等待回复，用!?操作符：

val reply = account !? Deposit(1000)
reply match {
    case Balance(bal) => println("Current Balance: " + bal)
}

接收方必须返回一个消息给发送方：

receive {
    case Deposit(amount) => {balance += amount; sender ! Balance(balance)}
}

可以使用receiveWithin方法指定你想要等待多少时间：

actor {
    worker ! Task(data, self)
    receiveWithin(seconds * 1000) {
        case Result (data) => ...
        case TimeOUT => log(...)
    }
}

可以使用!!来接受一个future—这是一个将在结果可用时产生结果的对象。

val replayFuture = account !! Deposit(100)

val replay = replyFuture()
//这个调用将会阻塞，直到回复被发送。

actor的act方法在actor的start方法被调用时开始执行。

def act {
    while(有更多事情要处理) {
        receive {
            ...
        }
    }
}

actor在如下情形之一会终止执行：

1. act方法返回。

2. act方法由于异常被终止。

3. actor调用exit方法。

def act () {
    link (master)
    ...
}

连接是双向的。

一些建议：

1. 避免使用共享状态。
2. 不要调用actor的方法。
3. 保持每个actor的简单。
4. 将上下文数据包含在消息中。
5. 最小化给发送方的回复。
6. 最小化阻塞调用。
7. 尽可能使用react.
8. 建立失败区。

版权声明：本文为博主原创文章，未经博主允许不得转载。