scala并发编程

并发编程的优点和风险
http://blog.csdn.net/jiyiqinlovexx/article/details/51002504
从scala2.10开始Actor模块已被移除，应使用Akka框架中的Actor
http://akka.io/try-akka/
Actor可以看作一个个独立的实体，之间毫无关联，通过消息通信，消息可以是任何类型，内容也可以是任意的，
Actor提供了一种不共享任何数据、依赖消息传递。类似于·线程的实体，有一个用来接收消息的邮箱。在并发编程中，Actor相对与使用共享数据和锁模型的实现，推断和使用更容易。
1、 Actor的构建方式
1） 继承Actor类
继承Actor类，重写act方法，

object Demo extends Actor{
def act():Unit={
println(“HelloActor!”)//Actor启动act方法，
}
def main(args:Array[String])={
Demo.start()
}
}

2)Actor工具方法

import scala.actors.Actor._
object Demo{
def main(args:Array[String]){
val myActor=actor{
println(“hello Actor!”)
}
}
}

2、 Actor的生命周期
start方法的等幂性
Reactor是所有Actor trait 的父级trait，扩展这个trait可以定义Actor，其具有发送和接收信息的基本功能，Reactor的行为通过其act方法来定义，调用start方法启用Reactor，act方法便执行，start方法返回Reactor对象本身，
在一个已经启动的Actor对象调用start是没用的。

object Test extends Actor{
def main(args:Array[String]){
println(Test.getState)
Test.start()
Test.start()
Thread.sleep(5000)
println(Test.getState)
Test.restart()
}
def act(){
println(Test.getState)
println(“act is excuted”)
}
}

输出是

New
Runnable
act is excuted
Terminated
Runable
act is excuted

Actor的不同状态，getState（）
New 尚未运行的Actor
Runnable 能够运行且不再等待消息的Actor
Suspended已挂起等待消息
Terminated已终止

Actor的生命周期
start方法 doStart方法 preAct方法 act方法 exit（）自然退出

restart（）重新启动

4、 Actor之间的通信
1、 Tip1：
Actor可以构造成带有指向一个或更多actor的引用。
2、 Tip2：
Actor可以接受带有指向另一个actor的引用的消息，在请求中提供一个actor引用非常常见。
3、 Tip3：
Actor可以返回消息给发送方。Receive会把sender字段设为当前消息的发送方。

使用val fut=a!!Msg语句发送信息，立即返回一个Future实例
HelloActor！”hello”,向HelloActor的信箱发送信息，HelloActor的receive方法通过PartialFunction偏函数匹配信息类型。
Future可以在不都塞的情况下可以通过isSet（）查询并获知结果是否可用，
Send-With-Future的消息并不是获得Future的唯一方法，Future也可以通过future方法计算。
!?方式，线程将堵塞指定结果返回

import actors._,Actor._
object DealMessage{
def main(args:Array[String]){
val caller=self
val accumulator=actor{
var continue=true
var sum=0
loopWhile(continue){
reactWhile(10000){
case number:Int=>sum+=number
case TIMEOUT= //超时
continue=false
caller!sum//向调用方发回计算结果
}
}
}
accumulator!2
Thread.sleep(5000)
accumulator!”hello”
Thread.sleep(5000)
accumulator!9
receiveWithin(60000){//设置超时时间60s
case result=>println(“result is:”+result)

}
}
}

5、 使用react重用线程提升性能
react是偏函数，找到并处理信息后并不返回，返回Nothing

object Demo extends Actor{
def act()={
react{
case (num:Int,actor:Actor)=>actor!num*num
case msg=>println(“not a Integer”)
}
}
def main(args:Array[String]){
Demo.start
Demo!(7,self)
self.receive{
case msg=>println(“收到结果：“+msg)
}
}
}

6、 Channel通道
某个实体的连接通道，通过Channel可以执行不同的I/O操作
OutputChannel发送信息
1） out!msg 异步地向out方法发送msg，可以传送actor的引用
2） out forward msg 异步，发送msg给一个actor时，发送中的actor会被确定
3） out.receiver 返回唯一的actor，其接受发送到out channel 的消息
4） out.send（msg,from） from发送msg到out
InputChannel接收信息
1） in.receive{case Pat1=>…;case Patn=>…}
2） in.rreact{case Pat1=>…;case Patn=>…}
创建和共享Channel

import scala.actora.{Channel,OutputChannel}
import scala.actors.Actor._
object Demo{
def main(args:Array[String]){
actor{
var out:OutputChannel[String=null
val channel=new Channel[String]//actor中定义一个channel
out=channel
val child=actor{
react{
case msg:String=>out!msg
}
}
child!”hello World”
channel.receive{
case msg=>println(“msg.length:”+msg.length)
}
}
}
}

7、 同步和Future
!方法发送完后就不管，
！！发送完就返回一个Future对象，占位符
!?发送后等待

编程实例：
http://blog.csdn.net/yyywyr/article/details/50465411