Actor实战、怎么实现actor并发编程、实现actor发送/接受消息、实现actor不断地接受消息、使用react方法代替receive接受消息、结合case class样例类发送/接收消息 19

1. 怎么实现actor并发编程

• 定义一个class或者是object继承Actor特质，注意导包import scala.actors.Actor
• 重写对应的act方法
• 调用Actor的start方法执行Actor
• 当act方法执行完成，整个程序运行结束

import scala.actors.Actor
//1. 定义一个object继承Actor
object Actor1 extends Actor{
	//2. 重写 act方法
	def act(){
		for(i <- 1 to 10){
			println("actor-1 " + i)
			Thread.sleep(2000)
		}
	}
}
object Actor2 extends Actor{
	//重写act方法
	def act(){
		for(i <- 1 to 10){
			println("actor-2 " + i)
			Thread.sleep(2000)
		}
	}
}	

//3. 调用Actor的start()方法执行Actor
object ActorTest extends Actor{
	Actor1.start()
	Actor2.start()
}

说明：上面分别调用了两个单例对象的start()方法，他们的act()方法会被执行，相同与java中开启了两个线程，线程的run()方法会被执行
注意：这两个Actor是并行执行的，act()方法中的for循环执行完成后actor程序就退出了。

2. 怎么实现actor发送、接受消息

• 定义一个class或者object继承Actor特质，注意导包import scala.actors.Actor
• 重写对应的act方法
• 调用**Actor的start()**方法执行Actor
• 通过不同发送消息的方式对actor发送消息
• act方法中通过receive方法接收消息并进行相应的处理
• act方法执行完成之后，程序退出

import scala.actors.Actor
//1. 继承Actor
class MyActor extends Actor{
	//2. 重写对应的act方法
	override def act(): Unit = {
		//5. 重写receive()方法接收消息
		receive {
			case "start" => {
				println("starting...")
			}
		}
	}
}
object MyActor{
	def main(args:Array[String]){
		//3.调用start()方法
		val actor = new MyActor
		actor.start()
		//4. 发送消息
		actor ! "start"	
		println("消息发送完成！")
	}
}

3. 怎么实现Actor可以不断地接收消息

在act()方法中可以使用while(true)的方式，不断地接收消息

import scala.actors.Actor
//1. 继承Actor
class MyActor1 extends Actor{
	//2. 实现act()方法
	override def act():Unit = {
	
		while(true){
			receive{
				case "start" => {
					println("starting...")
				}
				case "stop" => {
					println("stopping...")
				}
			}
		}
	}
}

//3. 调用start()方法
object MyActor1{
	def main(args:Array[String]){
		val actor = new MyActor1
		actor.start()
		actor ! "start"
		actor ! "stop"
	}
}

说明：在act()方法中加入了while (true) 循环，就可以不停的接收消息
注意：发送start消息和stop的消息是异步的，但是Actor接收到消息执行的过程是同步的按顺序执行

4. 使用react方法代替receive方法去接受消息

好处：react方式会复用线程，避免频繁的线程创建、销毁和切换。比receive更高效
注意: react 如果要反复执行消息处理，react外层要用loop，不能用while

import scala.actors.Actor
//1. 继承Actor
class YourActor extends Actor{
	//2. 实现act()方法
	override def act():Unit = {
		//循环接收消息
		loop{
			react{
				case "start" => {
					println("starting...")
				}
				case "stop" => {
					println("stopping...")
				}
			}
		}
	}
}
//3. 调用start()方法
object YourActor{
	def main(args:Array[String]){
		val actor = new YourActor
		actor.start()
		actor ! "start"
		actor ! "stop"
		println("消息发送完成！")
	}
}	

5. 结合case class样例类发送消息和接受消息

• 将消息封装在一个样例类中
• 通过匹配不同的样例类去执行不同的操作
• Actor可以范湖消息给发送方，通过sender方法向当前消息发送方返回消息

import scala.actors.Actor

//样例类
case class SyncMessage(id:Int,msg:String) //同步消息
case class AsyncMessage(id:Int,msg:String) //异步消息
case class ReplyMessage(id:Int,msg:String) //返回结果消息

//定义一个类继承Actor
class MsgActor extends Actor{
	//重写act()方法
	override def act():Unit = {
		loop{
			react{
				case "start" =>{println("starting...")}
				case SyncMessage(id,msg) =>{
					println(s"di:$id,SyncMessage:$msg")
					Thread.sleep(2000)
					sender ! ReplyMessage(1,"finished...")
				}
				 case AsyncMessage(id,msg)=>{
          			println(s"id:$id,AsyncMessage: $msg")
         			// Thread.sleep(2000)
        		  sender !ReplyMessage(3,"finished...")
          			Thread.sleep(2000)
      		  }
				
			}
		}
	}
}

//启动start()方法
object MainActor{
	def main(args:Array[String]):Unit = {
		val mActor = new MsgActor
			mActor.start()
			mActor ! "start"
		//发送同步消息，有返回值
		val reply1 = mActor !? SyncMessage(1,"我是同步消息")
		println(reply1)
		println("=========================")
		//发送异步消息，无返回值
		val reply2 = mActor ! AsyncMessage(2,"我是异步无返回消息")
		println("=========================")
		//发送异步消息，有返回值
		val reply3 = mActor !! AsyncMessage(3, "我是异步有返回值消息")
		//Future的apply()方法会构建一个异步操作且在为了某一个时刻返回一个值
		val result = reply3.apply()
		println(result)
	}
}