Scala与Golang的并发实现对比

// Akka并发计算实例

import akka.actor.Actor
import akka.actor.Props
import akka.actor.ActorSystem
import akka.routing.RoundRobinPool
 
// 定义一个case类
sealed trait SumTrait
case class Result(value: Int) extends SumTrait
 
// 计算用的Actor
class SumActor extends Actor {
  val RANGE = 10000
 
  def calculate(start: Int, end: Int, flag : String): Int = {
    var cal = 0
 
    for (i <- (start to end)) {
      for (j <- 1 to 3000000) {}
      cal += i
    }
 
    println("flag : " + flag + ".")
    return cal
  }
 
  def receive = {
    case value: Int =>
      sender ! Result(calculate((RANGE / 4) * (value - 1) + 1, (RANGE / 4) * value, value.toString))
    case _ => println("未知 in SumActor...")
  }
}
 
// 打印结果用的Actor
class PrintActor extends Actor {
  def receive = {
    case (sum: Int, startTime: Long) =>
      println("总数为：" + sum + "；所花时间为："
              + (System.nanoTime() - startTime)/1000000000.0 + "秒。")
    case _ => println("未知 in PrintActor...")
  }
}
 
// 主actor，发送计算指令给SumActor，发送打印指令给PrintActor
class MasterActor extends Actor {
  var sum = 0
  var count = 0
  var startTime: Long = 0
 
  // 声明Actor实例，nrOfInstances是pool里所启routee（SumActor）的数量，
  // 这里用4个SumActor来同时计算，很Powerful。
  val sumActor   = context.actorOf(Props[SumActor]
                    .withRouter(RoundRobinPool(nrOfInstances = 4)), name = "sumActor")
  val printActor = context.actorOf(Props[PrintActor], name = "printActor")
 
  def receive = {
    case "calculate..." =>
      startTime = System.nanoTime()
      for (i <- 1 to 4) sumActor ! i
    case Result(value) =>
      sum += value
      count += 1
      if (count == 4) {
        printActor ! (sum, startTime)
        context.stop(self)
      }
    case _ => println("未知 in MasterActor...")
  }
}
 
object Sum {
  def main(args: Array[String]): Unit = {
    var sum = 0
 
    val system = ActorSystem("MasterActorSystem")
    val masterActor = system.actorOf(Props[MasterActor], name = "masterActor")
    masterActor ! "calculate..."
 
    Thread.sleep(5000)
    system.shutdown()
  }
}

val sumActor   = context.actorOf(Props[SumActor]
                  .withRouter(RoundRobinPool(nrOfInstances = 4)), name = "sumActor")

for (i <- 1 to 4) sumActor ! i 

...
val RANGE = 10000
var cal = 0
val startTime = System.nanoTime()
 
for (i <- (1 to RANGE)) {
  for (j <- 1 to 3000000) {}
    cal += i
}
 
val endTime = System.nanoTime()
...

// Go并发计算实例
 
package main
 
import (
     "fmt"
     "runtime"
     "strconv"
     "time"
)
 
type Sum []int
 
func (s Sum) Calculate(count, start, end int, flag string, ch chan int) {
     cal := 0
 
     for i := start; i <= end; i++ {
          for j := 1; j <= 3000000; j++ {
          }
          cal += i
     }
 
     s[count] = cal
     fmt.Println("flag :", flag, ".")
     ch <- count
}
 
func (s Sum) LetsGo() {
     // runtime.NumCPU()可以获取CPU核数，我的环境为4核，所以这里就简单起见直接设为4了
     const NCPU = 4
     const RANGE = 10000
     var ch = make(chan int)
 
     runtime.GOMAXPROCS(NCPU)
     for i := 0; i < NCPU; i++ {
          go s.Calculate(i, (RANGE/NCPU)*i+1, (RANGE/NCPU)*(i+1), strconv.Itoa(i+1), ch)
     }
 
     for i := 0; i < NCPU; i++ {
          <-ch
     }
}
 
func main() {
     var s Sum = make([]int, 4, 4)
     var sum int = 0
     var startTime = time.Now()
 
     s.LetsGo()
 
     for _, v := range s {
          sum += v
     }
 
     fmt.Println("总数为：", sum, "；所花时间为：",
          (time.Now().Sub(startTime)), "秒。")
}

ch <- count 

for i := 0; i < NCPU; i++ {
    <-ch
}

for {
    select {
    case <-ch: ...
    case <-time.After(3 * time.Second): ...
    }
}

for _, v := range s {
    sum += v
}

...
cal := 0
 
for i := start; i <= end; i++ {
    for j := 1; j <= 3000000; j++ {
    }
    cal += i
}
...

scalac -cp lib\akka-actor_2.11-2.3.4.jar Sum.scala
scala Sum
 
go build Sum.go
Sum