Life is short
相信不少码农曾看过类似“life is short, use Python”等之类略带调侃意味的小段子（譬如我），而其也并非不无道理。每门编程语言都是合理的存在，都有它们的优点，及缺陷。
码农们也大多学过用过不止一门语言，譬如我。
像我这样曾胡摸过 N 门语言，但只会勉强熟练使用其中两三门或三四门的码农（C++、C#、Delphi、Golang），却还是想浅浅地比较一下它们，算是一点皮毛心得吧。
从这个偶然看到的例子开始。
uses
SyncObjs, System.Threading, System.Diagnostics;
{function local to the unit}
function IsPrime (N: Integer): Boolean;
var
Test: Integer;
begin
IsPrime := True;
for Test := 2 to N - 1 do
if (N mod Test) = 0 then
begin
IsPrime := False;
break; {jump out of the for loop}
end;
end;
const
Max = 100000; // 100K
procedure TFormParallelFor.btnPlainForLoopClick(Sender: TObject);
var
I, Tot: Integer;
Ticks: Cardinal;
begin
// counts the prime numbers below a given value
Tot := 0;
Ticks := GetTickCount;
for I := 1 to Max do
begin
if IsPrime (I) then
Inc (Tot);
//Application.ProcessMessages;
end;
Ticks := GetTickCount - Ticks;
Memo1.Lines.Add (Format (
'Plain for: %d - %d', [Ticks, Tot]));
end;
procedure TFormParallelFor.btnParallelForLoopClick(Sender: TObject);
var
Tot: Integer;
Ticks: Cardinal;
begin
Tot := 0;
Ticks := GetTickCount;
TParallel.For(1, Max, procedure (I: Int64)
begin
if IsPrime (I) then
InterlockedIncrement (Tot);
end);
Ticks := GetTickCount - Ticks;
Memo1.Lines.Add (Format (
'Parallel for: %d - %d', [Ticks, Tot]));
end;
Delphi XE7 新引入了一个并发辅助库（似乎由 Allen Bauer 操的刀），针对多核编程提供了语言层面上的支持。刚好在逛 Embarcadero 论坛的时候看到了这篇浅显的文章，得知 Delphi 是通过其自实现的可自动伸缩、非常智能的线程池的方式来实现对并发的支持，其中有一条定义引起了我的注意：MaxThreadsPerCPU = 25（当然我还不清楚为何每个核上挂的最大线程数量是 25）。我已懒得去下载去安装庞大的 XE7 去看其相关的 RTL 源码了，但既然我刚好又有个官方的小 Demo，索性跑跑看，如下。
看上去确实，这个并行库是比较不错的。
于是我有点心痒了，不知如果用 Golang 来做同样的实现，速度会如何呢？如下（注：因只想单纯测试 goroutine 和 channel，所以实现代码没有使用原子操作包 sync/atomic 提供的功能。而我并不熟 OpenMP，所以也没作这方面的对比）。
// ParallelCalcDemo project main.go
package main
import (
"fmt"
"runtime"
"time"
)
const cNumMax = 100000
func IsPrime(num int) bool {
ret := true
for i := 2; i < num; i++ {
if num%i == 0 {
ret = false
break
}
}
return ret
}
func plainCalc() {
cnt := 0
t1 := time.Now()
for i := 1; i <= cNumMax; i++ {
if IsPrime(i) {
cnt++
}
}
t2 := time.Now()
fmt.Printf(" plainCalc - Counts: %d; Time: %dms\n", cnt, t2.Sub(t1)/time.Millisecond)
}
func parallelHandle(numMin, numMax int, ch chan int) {
cnt := 0
for i := numMin; i <= numMax; i++ {
if IsPrime(i) {
cnt++
}
}
ch <- cnt
}
func parallelCalc(numGoroutines int) {
t1 := time.Now()
chans := make(chan int, numGoroutines)
seg := cNumMax / numGoroutines
if cNumMax%numGoroutines != 0 {
seg++
}
for i := 0; i < numGoroutines-1; i++ {
go parallelHandle(1+i*seg, (i+1)*seg, chans)
}
go parallelHandle(1+(numGoroutines-1)*seg, cNumMax, chans)
cnt := 0
for i := 0; i < numGoroutines; i++ {
cnt += <-chans
}
t2 := time.Now()
fmt.Printf(" parallelCalc - Counts: %d; Time: %dms\n", cnt, t2.Sub(t1)/time.Millisecond)
}
func parallelHandle2(value int, ch chan int) {
if IsPrime(value) {
ch <- 1
return
}
ch <- 0
}
func parallelCalc2() {
t1 := time.Now()
chans := make(chan int, cNumMax)
for i := 1; i <= cNumMax; i++ {
go parallelHandle2(i, chans)
}
cnt := 0
for i := 1; i <= cNumMax; i++ {
cnt += <-chans
}
t2 := time.Now()
fmt.Printf("parallelCalc2 - Counts: %d; Time: %dms\n", cnt, t2.Sub(t1)/time.Millisecond)
}
func main() {
numGoroutines := runtime.NumCPU()
runtime.GOMAXPROCS(numGoroutines)
plainCalc()
parallelCalc(numGoroutines)
parallelCalc2()
}
小跑 10 次，结果如下。
可见效率也还是可以的，虽然比 Delphi 的并行版本要慢几个百分点。只是既然前文有提到 25 这个数字，我想为何不尝试下将 GOMAXPROCS 设为 runtime.NumCPU() * 25 呢？如是略作改动之前的代码，得到如下结果。
于是竟然发现，（并行）效率似乎比修改前的要高一点，跟 Delphi 的并行版本基本差不多了。综合网上的一些信息，似乎 Golang 的调度器还是不够“NB”:)
当然，譬如对于 parallelCalc2 版本的实现，可能只是因开了 100K 个 goroutine 后引来的丁点调度效率损失而已。
但即便如此，即便只是通过上面简单的代码片段，我们还是可以看到，在 Golang 里实现并发实在是太方便了，goroutine 和 channel 实在是非常廉价却又非常简洁高效的并发利器。而这样的特性对于服务器端开发来说同样非常有用且重要，很大程度上简化了服务器端的多线程相关逻辑。在语言核心层面支持并行和分布式，并发模型简洁高效，简直是天生的后端开发牛刀。
譬如如下的代码片段，正是其威力的小小体现。
// SimpleTcpServer project main.go
package main
import (
"fmt"
"net"
"strings"
)
func main() {
fmt.Println("Starting the server...")
listener, err := net.Listen("tcp", "localhost:50000")
if err != nil {
fmt.Println("Error listening", err.Error())
return
}
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting", err.Error())
return
}
go doStuff(conn)
}
}
func doStuff(conn net.Conn) {
for {
buf := make([]byte, 512)
_, err := conn.Read(buf)
if err != nil {
fmt.Println("Error reading", err.Error())
return
}
fmt.Printf("Received data: %v", strings.Trim(string(buf), " "))
}
}
所以，Golang 还是有点意思的，对吧？
刚开始学习 Golang 时，其似乎有点“反人类”的语法曾让我比较不适应（估计不少码农或多或少也会如此感觉），但熟悉一段时间后居然也算很快就看顺眼了。其譬如 comma, ok form、类型推导（当然 C++11 有 auto，C# 也有这语法特性）、延迟执行等语法糖特性确实比较简洁，但同时却功能强大且实用，写惯了 try..catch / try...except...finally等类似代码、习惯了通过各种手段来释放清除资源的我们，在遇到 comma, ok、defer 等这样非常简洁的语法时，会不会有惊喜甚至拍案叫绝的感受呢（对于我，好像有过）？
顺便提一句，C# 里的 try..except..finally 类似于 Delphi 的相关语法，但不同的是后者却只有 try..except 和 try..finally，一直都没有加入前者这样的增强特性，我有点想不通。
我们习惯了输入/遇到类似 private、public、protected 等所谓关键字，甚至更甚，internal、protected internal 等，而 Golang 仅以首字符大小写来控制访问权限实现相同效果，不能不说比较新颖、简洁。有时候我居然会想，譬如 C++ / C# 引入了许多确实看起来实用的语法糖，但它们很少甚至极少用到，且绝大多数完全可以由用户（即码农）改进其设计的方式来实现，而既如此，为什么要引入那些呢，它们真的对所谓的软件工程有比较明显的益处？
C++ 有那么多的语言语法特性，但扪心自问，我们实际开发中真正用到了多少？大多数时候我们都只是使用其很小的一部分子集而已。而其本身的语言复杂度，带来了大幅提升的学习及使用成本，带来了非常复杂冗长的编译过程，也带来了（不合格）程序员滥用某些特性的可能。即便它能生成非常高效（及紧凑的）的机器码，但这背后的成本实在太大了。
再顺便提一句，说到 private、public 等，Delphi 的 published 特性确实对写 UI 相关的程序时非常好用且很实用，相信用过 Delphi 的码农会有体会（C# 码农同理）。
用 C++ 做 UI？唉。
getter / setter？ property 多么好的包装了它们。
我曾想在 C++ 里模拟 Delphi 的 initialization 和 finalization 特性，但却没能很好的如愿（当然，C++Builder 有这个特性）。但 Golang 提供了 init，这样的语言设计细节，还是带给我不少欢喜的（Golang 有 GC，所以 finalization 存在的意义不大）。
然后是譬如代码格式化等算不上语言特性的特性，我个人还是感觉比较有意义且实用的，尤其是对于有所谓代码洁癖的码农来说:)
同样，无需分号结束每行代码等特性，确是有点实际意义的，而这些点滴的语言特性累积，才能便于使用它的码农写出简洁、直观的代码。
只是，虽然 Golang 的 goroutine / channel 很强大简洁，但还是需要不少实践及实例去领会理解，譬如下面这段看似简单的代码，是不是有些“抽象”:)
// primesieve project main.go
package main
import (
"fmt"
)
// Send the sequence 2, 3, 4, ... to channel ch
func generate(ch chan int) {
for i := 2; ; i++ {
ch <- i
}
}
// Copy the values from channel in to channel out, removing those divisible by prime
func filter(in, out chan int, prime int) {
for {
i := <-in
if i%prime != 0 {
out <- i
}
}
}
func main() {
ch := make(chan int)
go generate(ch)
for {
prime := <-ch
fmt.Print(prime, " ")
ch1 := make(chan int)
go filter(ch, ch1, prime)
ch = ch1
}
}
但既然 goroutine / channel 的作用是那么大，用起来又这样简洁，把花在研究奇技淫巧上的时间拿来学习领会它们，为何不可？
Life is short, try Golang。
作为曾重度使用过 Delphi 的码农，很费解为何其一直在标榜所谓的数据库开发，即便两年前移动游戏开发已开始如火如荼，它却始终没能提供，或支持其爱好者提供可用的框架（想想下 Cocos2d 吧）。这次大潮它没赶上，估计也不会赶上了。顺势太重要，错过难再有。
虽然它早已能做多平台的应用开发，但始终，它恐怕只将自身定位为所谓的应用 APP 开发工具而已，中庸普通且平凡。
即便在某些方面，它确实很方便，甚至是利器。
