Scala.Actor实践心得与设计思想

   这段时间系统的学习了Scala，编程思想上可谓收获不少，想从里面挑些值得写的东西分享给大家，Scala的Actor

可谓这门语言的一个亮点，函数式编程核心价值在于多核编程，所以就打算说说这个Actor，总结一下学习心得。先很俗

套的简单谈谈概念，然后会拿四个例子做补充。主要内容包括基本原理，设计思想，单机环境并发测试。

 

 

  　　        Actor是一种基于事件的轻量级线程，在以前的并发模型中，我们需要关注共享的数据结构，而使用Actor则需要

关注操作数据的代码结构，因为减少了数据的共享。Actor的主要能力来源于消息传递，而不是采用阻塞调用的处理形式。

如果创建直接或间接扩展 Actor的类，要确保对对象的所有调用都通过消息传递进行。

 

　　   我把Actor的设计思想归为两类，使用目的归为两类。从设计思想上来说Scala推荐的是以消息传递为核心的设计

思想，由于Scala可以无缝使用Java类库，所以也可以采用以共享数据为核心的设计，当然也可以写出混合式设计风格的

。使用目的主要有两种，一种是Scala提供API给Java调用，另一种就是Scala自给自足。举三个例子，例子很简单，是一

个累加器。

 

1、以消息传递为核心的设计：使用Actor的actor方法，使用不可变对象，不考虑数据共享问题，以消息传递为设计核心。

 

 1 import actors._, Actor._
 2 /*
 3  * Author:ShiYang
 4  * Blog：http://shiyangxt.cnblogs.com
 5  * */
 6 object SendMessageStyle {
 7 
 8   def main(args: Array[String]): Unit = {
 9     val caller = self
10     val accumulator = actor {
11       var continue = true
12       var sum = 0
13       loopWhile(continue) {
14         reactWithin(500) {
15           case number: Int => sum += number
16           case TIMEOUT =>
17             continue = false
18             caller ! sum
19         }
20       }
21     }
22     accumulator ! 1
23     accumulator ! 2
24     accumulator ! 3
25     receiveWithin(1000) {
26       case result => println("Total is " + result)
27     }
28   }
29 }

 

2、以共享数据为核心的设计：构建由Actor继承共享数据操作类，以共享数据为核心。

 

 1 import actors._, Actor._
 2 
 3 /*
 4  * Author:ShiYang
 5  * Blog：http://shiyangxt.cnblogs.com
 6  * */
 7 object SharedDataStyle {
 8   case class Add(number: Int)
 9   case class GetResult(sender: Actor)
10 
11   class AddActor extends Actor {
12     override def act(): Unit = process(0)
13     def process(value: Int): Unit = {
14       reactWithin(500) {
15         case Add(number) => process(value + number)
16         case GetResult(a) => a ! value; process(value)
17         case _ => process(value)
18       }
19     }
20   }
21 
22   def main(args: Array[String]): Unit = {
23     val addActor = new AddActor
24     addActor.start()
25     addActor ! Add(1)
26     addActor ! Add(2)
27     addActor ! Add(3)
28     addActor ! GetResult(self)
29     receiveWithin(1000) {
30       case result => println("Total is " + result)
31     }
32   }
33 }

 

3、以API形式提供给Java程序使用：由于Java不能直接向Actor发消息，所以需要对Scala的!()方法进行封装。

 

 1 import actors._, Actor._
 2 /*
 3  * Author:ShiYang
 4  * Blog：http://shiyangxt.cnblogs.com
 5  * */
 6 object ForJavaStyle {
 7   case class Add(number: Int)
 8   case class GetResult(sender: Actor)
 9   private class AddActor extends Actor {
10     override def act(): Unit = process(0)
11     def process(value: Int): Unit = {
12       reactWithin(500) {
13         case Add(number) => process(value + number)
14         case GetResult(a) => a ! value; process(value)
15         case _ => process(value)
16       }
17     }
18   }
19   private val addActor = new AddActor
20   addActor.start()
21   private def add(sender: Actor, num: Int): Unit = {
22     sender ! Add(num)
23   }
24   private def getResult(sender: Actor): Int = {
25     sender ! GetResult(self)
26     receiveWithin(1000) {
27       case result: Int => result
28     }
29   }
30   def addForJava(num: Int): Unit = {
31     add(addActor, num)
32   }
33   def getResultForJava(): Int = {
34     getResult(addActor)
35   }
36 }

 

Java端调用代码：

 

 1 /*
 2  * Author:ShiYang
 3  * Blog：http://shiyangxt.cnblogs.com
 4  * */
 5 public class GetFromScala {
 6 
 7     public static void main(String[] args) {
 8         ForJavaStyle$.MODULE$.addForJava(1);
 9         ForJavaStyle$.MODULE$.addForJava(2);
10         ForJavaStyle$.MODULE$.addForJava(3);
11         System.out.println("Total is "
12                 + ForJavaStyle$.MODULE$.getResultForJava());
13     }
14 }

 

      通过上面的例子可见Scala对Java语言有非常大的补充，提高了生产力。为Java提供了轻松实现多核并行编程的能

力。为了进一步测试Actor的并发性能，于是做了一个简单的单机环境并发测试。程序是构建一个Actor动态有序数组，

并发创建N个Actor对象，为了证明这些对象全都可用，顺序从数组的第一个Actor发消息到最后一个Actor，只有当一个

Actor接收到前一个Actor发送的消息后，才向后一个Actor发送消息。当最后一个数组元素接收到消息后，再把消息从数组

尾部用同样处理过程逆序发送到数组头部。这个消息发送过程不是并发处理，是顺序处理。这里只是为了证明这些对象全都

可用。如果为了测试并发处理，可以修改程序，让每个数组元素给后一位数组元素发消息。这样就会看到输出混乱的发送信

息，因为并发是无序的。

 

测试环境：双核4G内存，Windows XP，Sun JVM1.6，单机环境，Scala版本2.9.0.1

 

测试结果：当使用Receive方法接收消息时，由于Receive会在结束任务前一直持有线程，而Scala在后台默认只给Receive

方法启动256个线程，我的程序又是顺序的发消息，而且不是临时接收器（只处理一次消息），所以Receive在这种情况下，

只有255个并发。React接收器由于不需要长期持有线程，空闲即释放线程。所以React在本程序中可以跑20w的并发，如果

简单优化一下JVM，就可以达到100w的并发量。默认React接收器后台会调用4个线程组成的线程池。如果修改程序让每个数

组元素给后一位数组元素并发的发消息，那么在不阻塞线程的情况下，Receive方法也可以达到和React一样的并发量。因为

这个测试程序是顺序发送消息，所以就没有设置超时，如果是并发环境，建议加上超时，避免线程阻塞。

 

下面是测试程序：

 

 1 import actors._, Actor._, java.util._
 2 /*
 3  * Author:ShiYang
 4  * Blog：http://shiyangxt.cnblogs.com
 5  * */
 6 object ConcurrentTest {
 7 
 8   val actors = new ArrayList[Actor]
 9   val length = 1000000
10   var startTime = System.nanoTime
11 
12   def main(args: Array[String]): Unit = {
13     for (i <- 0 to length)
14       actors.add(actor {
15         info("react: " + i + " actor created")
16         reactMessage
17       })
18     actors.get(0) ! (0, 0)
19   }
20 
21   def info(msg: String) = println(msg + " received by " +
22     Thread.currentThread)
23 
24   def receiveMessage {
25     var continue = true
26     while (continue) {
27       receive {
28         case (id: Int, direction: Int) =>
29           sendMessage(id: Int, direction: Int)
30         case "finish" =>
31           continue = false
32           val endTime = System.nanoTime
33           println("Finish, spend time:" +
34             (endTime - startTime) / 1000000000.0 + " secs")
35         case _ => println("input error")
36       }
37     }
38   }
39 
40   def reactMessage {
41     var continue = true
42     loopWhile(continue) {
43       react {
44         case (id: Int, direction: Int) =>
45           sendMessage(id: Int, direction: Int)
46         case "finish" =>
47           continue = false
48           val endTime = System.nanoTime
49           println("Finish, spend time:" +
50             (endTime - startTime) / 1000000000.0 + " secs")
51         case _ => println("input error")
52       }
53     }
54   }
55 
56   //direction=0->sendLatter;direction=1->sendFormer
57   def sendMessage(id: Int, direction: Int) {
58     if (direction == 0 && id != length) {
59       info("Actor" + id + " send message to the Actor" + (id + 1))
60       actors.get(id + 1) ! (id + 1, 0)
61     } else if (id != 0 && direction == 1) {
62       info("Actor" + id + " send message to the Actor" + (id - 1))
63       actors.get(id - 1) ! (id - 1, 1)
64     } else if (direction == 0 && id == length) {
65       actors.get(length) ! (length, 1)
66     } else if (id == 0 && direction == 1) {
67       actors.get(0) ! "finish"
68     }
69   }
70 }

 

       前些天看到Scala正在努力支持.net平台，不过我觉得.net平台有F#，所以对于.net程序员来说Scala提供不了什么

附加价值。如果非要找出来这样做的优点的话，就是Scala可以同时支持两个主流平台，野心不小。如果看后有所收获，请

推荐让更多人看到，算我为Scala的推广尽了点绵薄之力。行文仓促，如果有不对的地方，欢迎指正。