无意中看到这篇文章，开始还以为是在Java中实现Threadless的并发，结果看下去才发现是基于JVM的一门语言 Scala。它面向对象，函数式，静态类型，更重要是克隆了Erlang里面的进程间通讯的概念。

下载后，使用它的编译器编译，生成了很多.class，原来不是用Java来解析执行，而是编译成JVM兼容的字节码，并且能够调用java类库。这里是一个PingPong的例子

package examples.actors

import scala.actors.Actor
import scala.actors.Actor._

abstract class PingMessage
case class MsgStart() extends PingMessage
case class MsgPingInit(count: int, pong: Pong) extends PingMessage
case class MsgSendPing extends PingMessage
case class MsgPong(sender: Pong) extends PingMessage

abstract class PongMessage
case class MsgPing(sender: Ping) extends PongMessage
case class MsgStop() extends PongMessage

object PingPong {
  def main(args : Array[String]): Unit = {
    val ping = new Ping
    ping.start
    val pong = new Pong
    pong.start
    ping ! MsgPingInit(100000, pong)
    ping ! MsgStart
  }
}

class Ping extends Actor {
  def act(): unit = {
    loop(0, null)
  }
  def loop(pingsLeft: int, pong: Pong): unit = {
    react {
      case MsgPingInit(count, pong) => {
        System.out.println("Ping: Initializing with count:"+count+":"+pong)
        loop(count, pong)
      }
      case MsgStart() => {
        System.out.println("Ping: starting.")
        pong ! MsgPing(this)
        loop(pingsLeft-1, pong)
      }
      case MsgSendPing() => {
        pong ! MsgPing(this)
        loop(pingsLeft-1, pong)
      }
      case MsgPong(pidS) => {
        if (pingsLeft % 100 == 0) {
          System.out.println("Ping: pong from: "+pidS)
        }
        if (pingsLeft > 0)
          this ! MsgSendPing()
        else {
          System.out.println("Ping: Stop.")
          pong ! MsgStop()
        }
        loop(pingsLeft, pong)
      }
    }
  }
}

class Pong extends Actor {
  def act(): unit = {
    loop(0)
  }

  def loop(pongCount: int): unit = {
    react {
      case MsgPing(pidPing) => {
        if (pongCount % 100 == 0) {
          System.out.println("Pong: ping:"+pongCount+" from: "+pidPing)
        }
        pidPing ! MsgPong(this)
        loop(pongCount+1)
      }
      case MsgStop() => {
        System.out.println("Pong: Stop.")
        System.exit(0)
      }
    }
  }
}

编译：
D:\scala-2.3.3\bin>scalac -d classes D:\scala-2.3.3\doc\scala-devel\scala\exampl
es\actors\PingPong.scala

执行：scala -cp classes examples.actors.PingPong

输出：
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85300 from: examples.actors.Ping@dd87b2
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85400 from: examples.actors.Ping@dd87b2
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85500 from: examples.actors.Ping@dd87b2
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85600 from: examples.actors.Ping@dd87b2
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85700 from: examples.actors.Ping@dd87b2
Ping: pong from: examples.actors.Pong@1a73d3c
Pong: ping:85800 from: examples.actors.Ping@dd87b2

用JAD反编译了生成的.class，里面基本上没有用太多反射，性能应该还是值得信赖的。

这语言是05年开发的，现在最新版本2.3.3。感觉它只是克隆了微进程间消息通讯，模式匹配这些部分，对于分布这方面还没有涉及。关注之。