重新执行命令：eclipse 和 gen-sublime
9）JUnitSpringDemo -- 联网下载库依赖，解决上次“无效”的问题

	将单元测试之“DI框架--Spring”
11）异步系统测试 -- 测试工具Awaitility -- Demo之继续

用Specs2进行测试，故要补充相关依赖库 AwaitilityDemo/build.sbt

编写测试代码 AwaitilityDemo/src/test/scala/com/chaoskey/demo/OrderServiceSpecification.scala

重新生成eclipse支持
12）sbt-android-plugin安装配置 -- 有待联网下载依赖库后继续 ！！！！！
13）ActorStudy - 子项目初创

      见 ActorStudy/build.sbt

---------------------
AndroidDemo研究尝试 --  还未成功
13）ActorStudy正式开始 -- A simple actor

本项目例子来自 "Programming in Scala, 2nd Edition, Chapter 32\" 中的范例

1. 进入本项目
$sbt
> project actor-study

2. 键入书中本章的第一个例子：清单32.1 A simple actor

3. 在SBT提示符下编译：
> compile
  ------- 失败

4. 在ActorStudy/build.sbt中添加库依赖：
libraryDependencies <++= scalaVersion(v => Seq("org.scala-lang" % "scala-actors" % v))

5. 在SBT提示符下编译：
> reload
> compile
  ------- 成功

6. 有SBT提示符进入Scala控制台（会自动导入本项目的所有类）:
> console

7.在Scala提示符下执行：
scala> SillyActor.start()
res0: scala.actors.Actor = SillyActor$@3b0b19

scala> I'm acting!
I'm acting!
I'm acting!
I'm acting!
I'm acting!
13）ActorStudy继续 -- 验证actor是在独立的线程中运行的

注意到，第7步是在一个新的scala提示符下显示，这已经表明actor是独立于执行者线程的。

这里将进一步证明:actor相互之间也可以是在相互独立的线程中执行。

8.添加一个完全类似SillyActor的actor -- SeriousActor 并确认编译通过：
scala> :q
> compile

9. 同时运行这两个actor:
scala> SillyActor.start();SeriousActor.start()
res1: scala.actors.Actor = SeriousActor$@dcdd16

scala> To be or not to be.
I'm acting!
To be or not to be.
I'm acting!
To be or not to be.
I'm acting!
I'm acting!
To be or not to be.
To be or not to be.
I'm acting!

结论：
  注意到两个actor的打印结果交替进行，说明这两个actor在相互独立的线程中执行。
13）ActorStudy继续 -- 利用scala.actors.Actor.actor工具直接创建actor

10.建立一个名叫CommandExecute的object(详见代码及注释), 并确认编译通过：
scala> :q
> compile

11. 执行这段代码
> console

scala> CommandExecute.execute()
res0: scala.actors.Actor = scala.actors.Actor$$anon$1@1985730

scala> That is the question.
That is the question.
That is the question.
That is the question.
That is the question.

   --- 当然你也可以按代码注释说明直接在scala控制台执行相关代码
13）ActorStudy继续 -- actor的消息接受与处理

前面创建的两个actor (比如：SillyActor) 都仅用来表演了。
虽然都可以接受消息（保存在各自的“邮箱”中），但都没有被处理。

下面我们给SillyActor发送一个消息
scala> SillyActor ! "hi there"

      ---  对，正如我们所料 -- 没有响应。

12.在CommandExecute中：
   a.新建一个方法echoActor,用来创建一个能接受任意消息的actor
   b.新建一个方法intActor,用来创建一个只能接受整数消息的actor
确认编译通过：

scala> :q
> compile

13. 执行这段代码
> console

scala> val _echoActor = CommandExecute.echoActor()
_echoActor: scala.actors.Actor = scala.actors.Actor$$anon$1@1ade369

scala> _echoActor !  "hi there"

scala> received message: hi there

scala> _echoActor !  15
received message: 15

scala> val _intActor = CommandExecute.intActor()

scala> _intActor ! "hello"
                               ^
scala> _intActor ! 12

Got an Int: 12
13）ActorStudy继续 -- 将原生线程当成actor

	使用Actor.self可以将当前线程作为actor来查看

13.在CommandExecute中：
   新建一个方法send2self(msg: String),用来演示Actor.self的使用
确认编译通过：

scala> :q
> compile

13. 执行这段代码
> console

scala> CommandExecute.send2self("hello")
self ! hello
self.receive {case x => x} : hello
self.receiveWithin(1000) { case x => x } : TIMEOUT

 -----注意----
     send2self中的最后一个命令执行完后是无法退出当前scala命令行环境
     为了防止跑题，暂时忽略这个问题。
     我是关闭整个命令行界面，然后重启scala或sbt
13）ActorStudy继续 -- 通过重用线程获得更好的性能

	Scala提供了一种通常receive方法之外的的备选方法，叫做 react 。
区别在于： react在找到并处理消息后并不返回（返回类型：Nothing）;
         而receive会返回消息的处理结果

由于react方法不需要返回，其实现不需要暴力当前线程的调用栈。因此actor库可以在下一次被唤醒的线程中重用当前的线程。
如果程序中的每个actor都用使用react而不是的话，理论上每个CUP核只需要一个线程就能满足程序的的全部actor的需要.

16.创建一个名为NameResolver的Actor,确认编译通过：
scala> :q
> compile

17. 代码行为演示
> console

scala> import scala.actors.Actor._

scala> NameResolver.start()
res0: scala.actors.Actor = NameResolver$@7ad736

scala> NameResolver ! ("www.scala-lang.org",self)

scala> self.receiveWithin(0) {case x => x}
res2: Any = Some(www.scala-lang.org/128.178.154.102)

scala> NameResolver ! ("wwwwwww.scala-lang.org",self)

scala> self.receiveWithin(0) {case x => x}
res4: Any = None

    ---注意---
       NameResolver的每条消息处理后，如果不想退出处理的话，都要尾递归调用act()

-----------------------------------
CommandExecute的代码移到单独的文件中CommandExecute.scala,然后
> clean
> compile
13）ActorStudy继续 -- 通过重用线程获得更好的性能 之 补充

前一段，使用react的act()尾递归调用模式是如此常见，所以actor库对这种模式有特别的支持。

Actor.loop函数用来重复执行一个代码块，哪怕代码调用的是 react。

所以我们可以用loop来重写NameResolver的act方法。
13）ActorStudy继续 -- 使用助手actor来避免堵塞自己的actor

19.在CommandExecute中：
   新建一个方法helperActorDemo()
确认编译通过：
scala> :q
> compile

20. 代码运行结果
> console

scala> CommandExecute.helperActorDemo
Received: hi there
I'm acting!
I'm acting!
I'm acting!
I'm acting!
I'm acting!
exit actor.
13）ActorStudy继续 -- 使用样本类作为消息的actor

   21.以前面实现过的NameResolver为基础进行修改，演示代码见代码注释
13）CircuitSimulation - 子项目初创

    电路模拟

 根据"Programming in Scala, 2nd Edition"中的：

1. 第18章 有状态的对象  第3-6节

2. 第32章 actor和并发  第6节
14）CircuitSimulation - 模拟API的基本要素
14）CircuitSimulation - 模拟框架的实现
14）CircuitSimulation - 扩展了的电路模拟框架
14）CircuitSimulation - 描述线路的类
14）CircuitSimulation - 用“非门/与门/或门”进行线路连接