标签 C 下的文章

也谈goroutine调度器

Go语言在2016年再次拿下TIBOE年度编程语言称号,这充分证明了Go语言这几年在全世界范围内的受欢迎程度。如果要对世界范围内的gopher发起一次“你究竟喜欢Go的哪一点”的调查,我相信很多Gopher会提到:goroutine

GoroutineGo语言原生支持并发的具体实现,你的Go代码都无一例外地跑在goroutine中。你可以启动许多甚至成千上万的goroutine,Go的runtime负责对goroutine进行管理。所谓的管理就是“调度”,粗糙地说调度就是决定何时哪个goroutine将获得资源开始执行、哪个goroutine应该停止执行让出资源、哪个goroutine应该被唤醒恢复执行等。goroutine的调度是Go team care的事情,大多数gopher们无需关心。但个人觉得适当了解一下Goroutine的调度模型和原理,对于编写出更好的go代码是大有裨益的。因此,在这篇文章中,我将和大家一起来探究一下goroutine调度器的演化以及模型/原理。

注意:这里要写的并不是对goroutine调度器的源码分析,国内的雨痕老师在其《Go语言学习笔记》一书的下卷“源码剖析”中已经对Go 1.5.1的scheduler实现做了细致且高质量的源码分析了,对Go scheduler的实现特别感兴趣的gopher可以移步到这本书中去^0^。这里关于goroutine scheduler的介绍主要是参考了Go team有关scheduler的各种design doc、国外Gopher发表的有关scheduler的资料,当然雨痕老师的书也给我了很多的启示。

一、Goroutine调度器

提到“调度”,我们首先想到的就是操作系统对进程、线程的调度。操作系统调度器会将系统中的多个线程按照一定算法调度到物理CPU上去运行。传统的编程语言比如CC++等的并发实现实际上就是基于操作系统调度的,即程序负责创建线程(一般通过pthread等lib调用实现),操作系统负责调度。这种传统支持并发的方式有诸多不足:

  • 复杂

    • 创建容易,退出难:做过C/C++ Programming的童鞋都知道,创建一个thread(比如利用pthread)虽然参数也不少,但好歹可以接受。但一旦涉及到thread的退出,就要考虑thread是detached,还是需要parent thread去join?是否需要在thread中设置cancel point,以保证join时能顺利退出?
    • 并发单元间通信困难,易错:多个thread之间的通信虽然有多种机制可选,但用起来是相当复杂;并且一旦涉及到shared memory,就会用到各种lock,死锁便成为家常便饭;
    • thread stack size的设定:是使用默认的,还是设置的大一些,或者小一些呢?
  • 难于scaling

    • 一个thread的代价已经比进程小了很多了,但我们依然不能大量创建thread,因为除了每个thread占用的资源不小之外,操作系统调度切换thread的代价也不小;
    • 对于很多网络服务程序,由于不能大量创建thread,就要在少量thread里做网络多路复用,即:使用epoll/kqueue/IoCompletionPort这套机制,即便有libevent/libev这样的第三方库帮忙,写起这样的程序也是很不易的,存在大量callback,给程序员带来不小的心智负担。

为此,Go采用了用户层轻量级thread或者说是类coroutine的概念来解决这些问题,Go将之称为”goroutine“。goroutine占用的资源非常小(Go 1.4将每个goroutine stack的size默认设置为2k),goroutine调度的切换也不用陷入(trap)操作系统内核层完成,代价很低。因此,一个Go程序中可以创建成千上万个并发的goroutine。所有的Go代码都在goroutine中执行,哪怕是go的runtime也不例外。将这些goroutines按照一定算法放到“CPU”上执行的程序就称为goroutine调度器goroutine scheduler

不过,一个Go程序对于操作系统来说只是一个用户层程序,对于操作系统而言,它的眼中只有thread,它甚至不知道有什么叫Goroutine的东西的存在。goroutine的调度全要靠Go自己完成,实现Go程序内goroutine之间“公平”的竞争“CPU”资源,这个任务就落到了Go runtime头上,要知道在一个Go程序中,除了用户代码,剩下的就是go runtime了。

于是Goroutine的调度问题就演变为go runtime如何将程序内的众多goroutine按照一定算法调度到“CPU”资源上运行了。在操作系统层面,Thread竞争的“CPU”资源是真实的物理CPU,但在Go程序层面,各个Goroutine要竞争的”CPU”资源是什么呢?Go程序是用户层程序,它本身整体是运行在一个或多个操作系统线程上的,因此goroutine们要竞争的所谓“CPU”资源就是操作系统线程。这样Go scheduler的任务就明确了:将goroutines按照一定算法放到不同的操作系统线程中去执行。这种在语言层面自带调度器的,我们称之为原生支持并发

二、Go调度器模型与演化过程

1、G-M模型

2012年3月28日,Go 1.0正式发布。在这个版本中,Go team实现了一个简单的调度器。在这个调度器中,每个goroutine对应于runtime中的一个抽象结构:G,而os thread作为“物理CPU”的存在而被抽象为一个结构:M(machine)。这个结构虽然简单,但是却存在着许多问题。前Intel blackbelt工程师、现Google工程师Dmitry Vyukov在其《Scalable Go Scheduler Design》一文中指出了G-M模型的一个重要不足: 限制了Go并发程序的伸缩性,尤其是对那些有高吞吐或并行计算需求的服务程序。主要体现在如下几个方面:

  • 单一全局互斥锁(Sched.Lock)和集中状态存储的存在导致所有goroutine相关操作,比如:创建、重新调度等都要上锁;
  • goroutine传递问题:M经常在M之间传递”可运行”的goroutine,这导致调度延迟增大以及额外的性能损耗;
  • 每个M做内存缓存,导致内存占用过高,数据局部性较差;
  • 由于syscall调用而形成的剧烈的worker thread阻塞和解除阻塞,导致额外的性能损耗。

2、G-P-M模型

于是Dmitry Vyukov亲自操刀改进Go scheduler,在Go 1.1中实现了G-P-M调度模型work stealing算法,这个模型一直沿用至今:

img{512x368}

有名人曾说过:“计算机科学领域的任何问题都可以通过增加一个间接的中间层来解决”,我觉得Dmitry Vyukov的G-P-M模型恰是这一理论的践行者。Dmitry Vyukov通过向G-M模型中增加了一个P,实现了Go scheduler的scalable。

P是一个“逻辑Proccessor”,每个G要想真正运行起来,首先需要被分配一个P(进入到P的local runq中,这里暂忽略global runq那个环节)。对于G来说,P就是运行它的“CPU”,可以说:G的眼里只有P。但从Go scheduler视角来看,真正的“CPU”是M,只有将P和M绑定才能让P的runq中G得以真实运行起来。这样的P与M的关系,就好比Linux操作系统调度层面用户线程(user thread)与核心线程(kernel thread)的对应关系那样(N x M)。

3、抢占式调度

G-P-M模型的实现算是Go scheduler的一大进步,但Scheduler仍然有一个头疼的问题,那就是不支持抢占式调度,导致一旦某个G中出现死循环或永久循环的代码逻辑,那么G将永久占用分配给它的P和M,位于同一个P中的其他G将得不到调度,出现“饿死”的情况。更为严重的是,当只有一个P时(GOMAXPROCS=1)时,整个Go程序中的其他G都将“饿死”。于是Dmitry Vyukov又提出了《Go Preemptive Scheduler Design》并在Go 1.2中实现了“抢占式”调度。

这个抢占式调度的原理则是在每个函数或方法的入口,加上一段额外的代码,让runtime有机会检查是否需要执行抢占调度。这种解决方案只能说局部解决了“饿死”问题,对于没有函数调用,纯算法循环计算的G,scheduler依然无法抢占。

4、NUMA调度模型

从Go 1.2以后,Go似乎将重点放在了对GC的低延迟的优化上了,对scheduler的优化和改进似乎不那么热心了,只是伴随着GC的改进而作了些小的改动。Dmitry Vyukov在2014年9月提出了一个新的proposal design doc:《NUMA‐aware scheduler for Go》,作为未来Go scheduler演进方向的一个提议,不过至今似乎这个proposal也没有列入开发计划。

5、其他优化

Go runtime已经实现了netpoller,这使得即便G发起网络I/O操作也不会导致M被阻塞(仅阻塞G),从而不会导致大量M被创建出来。但是对于regular file的I/O操作一旦阻塞,那么M将进入sleep状态,等待I/O返回后被唤醒;这种情况下P将与sleep的M分离,再选择一个idle的M。如果此时没有idle的M,则会新创建一个M,这就是为何大量I/O操作导致大量Thread被创建的原因。

Ian Lance TaylorGo 1.9 dev周期中增加了一个Poller for os package的功能,这个功能可以像netpoller那样,在G操作支持pollable的fd时,仅阻塞G,而不阻塞M。不过该功能依然不能对regular file有效,regular file不是pollable的。不过,对于scheduler而言,这也算是一个进步了。

三、Go调度器原理的进一步理解

1、G、P、M

关于G、P、M的定义,大家可以参见$GOROOT/src/runtime/runtime2.go这个源文件。这三个struct都是大块儿头,每个struct定义都包含十几个甚至二、三十个字段。像scheduler这样的核心代码向来很复杂,考虑的因素也非常多,代码“耦合”成一坨。不过从复杂的代码中,我们依然可以看出来G、P、M的各自大致用途(当然雨痕老师的源码分析功不可没),这里简要说明一下:

  • G: 表示goroutine,存储了goroutine的执行stack信息、goroutine状态以及goroutine的任务函数等;另外G对象是可以重用的。
  • P: 表示逻辑processor,P的数量决定了系统内最大可并行的G的数量(前提:系统的物理cpu核数>=P的数量);P的最大作用还是其拥有的各种G对象队列、链表、一些cache和状态。
  • M: M代表着真正的执行计算资源。在绑定有效的p后,进入schedule循环;而schedule循环的机制大致是从各种队列、p的本地队列中获取G,切换到G的执行栈上并执行G的函数,调用goexit做清理工作并回到m,如此反复。M并不保留G状态,这是G可以跨M调度的基础。
下面是G、P、M定义的代码片段:

//src/runtime/runtime2.go
type g struct {
        stack      stack   // offset known to runtime/cgo
        sched     gobuf
        goid        int64
        gopc       uintptr // pc of go statement that created this goroutine
        startpc    uintptr // pc of goroutine function
        ... ...
}

type p struct {
    lock mutex

    id          int32
    status      uint32 // one of pidle/prunning/...

    mcache      *mcache
    racectx     uintptr

    // Queue of runnable goroutines. Accessed without lock.
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr

    runnext guintptr

    // Available G's (status == Gdead)
    gfree    *g
    gfreecnt int32

  ... ...
}

type m struct {
    g0      *g     // goroutine with scheduling stack
    mstartfn      func()
    curg          *g       // current running goroutine
 .... ..
}

2、G被抢占调度

和操作系统按时间片调度线程不同,Go并没有时间片的概念。如果某个G没有进行system call调用、没有进行I/O操作、没有阻塞在一个channel操作上,那么m是如何让G停下来并调度下一个runnable G的呢?答案是:G是被抢占调度的。

前面说过,除非极端的无限循环或死循环,否则只要G调用函数,Go runtime就有抢占G的机会。Go程序启动时,runtime会去启动一个名为sysmon的m(一般称为监控线程),该m无需绑定p即可运行,该m在整个Go程序的运行过程中至关重要:

//$GOROOT/src/runtime/proc.go

// The main goroutine.
func main() {
     ... ...
    systemstack(func() {
        newm(sysmon, nil)
    })
    .... ...
}

// Always runs without a P, so write barriers are not allowed.
//
//go:nowritebarrierrec
func sysmon() {
    // If a heap span goes unused for 5 minutes after a garbage collection,
    // we hand it back to the operating system.
    scavengelimit := int64(5 * 60 * 1e9)
    ... ...

    if  .... {
        ... ...
        // retake P's blocked in syscalls
        // and preempt long running G's
        if retake(now) != 0 {
            idle = 0
        } else {
            idle++
        }
       ... ...
    }
}

sysmon每20us~10ms启动一次,按照《Go语言学习笔记》中的总结,sysmon主要完成如下工作:

  • 释放闲置超过5分钟的span物理内存;
  • 如果超过2分钟没有垃圾回收,强制执行;
  • 将长时间未处理的netpoll结果添加到任务队列;
  • 向长时间运行的G任务发出抢占调度;
  • 收回因syscall长时间阻塞的P;

我们看到sysmon将“向长时间运行的G任务发出抢占调度”,这个事情由retake实施:

// forcePreemptNS is the time slice given to a G before it is
// preempted.
const forcePreemptNS = 10 * 1000 * 1000 // 10ms

func retake(now int64) uint32 {
          ... ...
           // Preempt G if it's running for too long.
            t := int64(_p_.schedtick)
            if int64(pd.schedtick) != t {
                pd.schedtick = uint32(t)
                pd.schedwhen = now
                continue
            }
            if pd.schedwhen+forcePreemptNS > now {
                continue
            }
            preemptone(_p_)
         ... ...
}

可以看出,如果一个G任务运行10ms,sysmon就会认为其运行时间太久而发出抢占式调度的请求。一旦G的抢占标志位被设为true,那么待这个G下一次调用函数或方法时,runtime便可以将G抢占,并移出运行状态,放入P的local runq中,等待下一次被调度。

3、channel阻塞或network I/O情况下的调度

如果G被阻塞在某个channel操作或network I/O操作上时,G会被放置到某个wait队列中,而M会尝试运行下一个runnable的G;如果此时没有runnable的G供m运行,那么m将解绑P,并进入sleep状态。当I/O available或channel操作完成,在wait队列中的G会被唤醒,标记为runnable,放入到某P的队列中,绑定一个M继续执行。

4、system call阻塞情况下的调度

如果G被阻塞在某个system call操作上,那么不光G会阻塞,执行该G的M也会解绑P(实质是被sysmon抢走了),与G一起进入sleep状态。如果此时有idle的M,则P与其绑定继续执行其他G;如果没有idle M,但仍然有其他G要去执行,那么就会创建一个新M。

当阻塞在syscall上的G完成syscall调用后,G会去尝试获取一个可用的P,如果没有可用的P,那么G会被标记为runnable,之前的那个sleep的M将再次进入sleep。

四、调度器状态的查看方法

Go提供了调度器当前状态的查看方法:使用Go运行时环境变量GODEBUG。

$GODEBUG=schedtrace=1000 godoc -http=:6060
SCHED 0ms: gomaxprocs=4 idleprocs=3 threads=3 spinningthreads=0 idlethreads=0 runqueue=0 [0 0 0 0]
SCHED 1001ms: gomaxprocs=4 idleprocs=0 threads=9 spinningthreads=0 idlethreads=3 runqueue=2 [8 14 5 2]
SCHED 2006ms: gomaxprocs=4 idleprocs=0 threads=25 spinningthreads=0 idlethreads=19 runqueue=12 [0 0 4 0]
SCHED 3006ms: gomaxprocs=4 idleprocs=0 threads=26 spinningthreads=0 idlethreads=8 runqueue=2 [0 1 1 0]
SCHED 4010ms: gomaxprocs=4 idleprocs=0 threads=26 spinningthreads=0 idlethreads=20 runqueue=12 [6 3 1 0]
SCHED 5010ms: gomaxprocs=4 idleprocs=0 threads=26 spinningthreads=1 idlethreads=20 runqueue=17 [0 0 0 0]
SCHED 6016ms: gomaxprocs=4 idleprocs=0 threads=26 spinningthreads=0 idlethreads=20 runqueue=1 [3 4 0 10]
... ...

GODEBUG这个Go运行时环境变量很是强大,通过给其传入不同的key1=value1,key2=value2… 组合,Go的runtime会输出不同的调试信息,比如在这里我们给GODEBUG传入了”schedtrace=1000″,其含义就是每1000ms,打印输出一次goroutine scheduler的状态,每次一行。每一行各字段含义如下:

以上面例子中最后一行为例:

SCHED 6016ms: gomaxprocs=4 idleprocs=0 threads=26 spinningthreads=0 idlethreads=20 runqueue=1 [3 4 0 10]

SCHED:调试信息输出标志字符串,代表本行是goroutine scheduler的输出;
6016ms:即从程序启动到输出这行日志的时间;
gomaxprocs: P的数量;
idleprocs: 处于idle状态的P的数量;通过gomaxprocs和idleprocs的差值,我们就可知道执行go代码的P的数量;
threads: os threads的数量,包含scheduler使用的m数量,加上runtime自用的类似sysmon这样的thread的数量;
spinningthreads: 处于自旋状态的os thread数量;
idlethread: 处于idle状态的os thread的数量;
runqueue=1: go scheduler全局队列中G的数量;
[3 4 0 10]: 分别为4个P的local queue中的G的数量。

我们还可以输出每个goroutine、m和p的详细调度信息,但对于Go user来说,绝大多数时间这是不必要的:

$ GODEBUG=schedtrace=1000,scheddetail=1 godoc -http=:6060

SCHED 0ms: gomaxprocs=4 idleprocs=3 threads=3 spinningthreads=0 idlethreads=0 runqueue=0 gcwaiting=0 nmidlelocked=0 stopwait=0 sysmonwait=0
  P0: status=1 schedtick=0 syscalltick=0 m=0 runqsize=0 gfreecnt=0
  P1: status=0 schedtick=0 syscalltick=0 m=-1 runqsize=0 gfreecnt=0
  P2: status=0 schedtick=0 syscalltick=0 m=-1 runqsize=0 gfreecnt=0
  P3: status=0 schedtick=0 syscalltick=0 m=-1 runqsize=0 gfreecnt=0
  M2: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=1 dying=0 helpgc=0 spinning=false blocked=false lockedg=-1
  M1: p=-1 curg=17 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 helpgc=0 spinning=false blocked=false lockedg=17
  M0: p=0 curg=1 mallocing=0 throwing=0 preemptoff= locks=1 dying=0 helpgc=0 spinning=false blocked=false lockedg=1
  G1: status=8() m=0 lockedm=0
  G17: status=3() m=1 lockedm=1

SCHED 1002ms: gomaxprocs=4 idleprocs=0 threads=13 spinningthreads=0 idlethreads=7 runqueue=6 gcwaiting=0 nmidlelocked=0 stopwait=0 sysmonwait=0

 P0: status=2 schedtick=2293 syscalltick=18928 m=-1 runqsize=12 gfreecnt=2
  P1: status=1 schedtick=2356 syscalltick=19060 m=11 runqsize=11 gfreecnt=0
  P2: status=2 schedtick=2482 syscalltick=18316 m=-1 runqsize=37 gfreecnt=1
  P3: status=2 schedtick=2816 syscalltick=18907 m=-1 runqsize=2 gfreecnt=4
  M12: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 helpgc=0 spinning=false blocked=true lockedg=-1
  M11: p=1 curg=6160 mallocing=0 throwing=0 preemptoff= locks=2 dying=0 helpgc=0 spinning=false blocked=false lockedg=-1
  M10: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 helpgc=0 spinning=false blocked=true lockedg=-1
 ... ...

SCHED 2002ms: gomaxprocs=4 idleprocs=0 threads=23 spinningthreads=0 idlethreads=5 runqueue=4 gcwaiting=0 nmidlelocked=0 stopwait=0 sysmonwait=0
  P0: status=0 schedtick=2972 syscalltick=29458 m=-1 runqsize=0 gfreecnt=6
  P1: status=2 schedtick=2964 syscalltick=33464 m=-1 runqsize=0 gfreecnt=39
  P2: status=1 schedtick=3415 syscalltick=33283 m=18 runqsize=0 gfreecnt=12
  P3: status=2 schedtick=3736 syscalltick=33701 m=-1 runqsize=1 gfreecnt=6
  M22: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 helpgc=0 spinning=false blocked=true lockedg=-1
  M21: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 helpgc=0 spinning=false blocked=true lockedg=-1
... ...

关于go scheduler调试信息输出的详细信息,可以参考Dmitry Vyukov的大作:《Debugging performance issues in Go programs》。这也应该是每个gopher必读的经典文章。当然更详尽的代码可参考$GOROOT/src/runtime/proc.go中的schedtrace函数。


微博:@tonybai_cn
微信公众号:iamtonybai
github.com: https://github.com/bigwhite

Go coding in go way

本篇文章是我在2017年第三届GopherChina大会上所作talk:”Go coding in go way“的改编和展开版,全文如下。

一、序

今天我要分享的题目是“Go coding in go way”,中文含义就是用“Go语言编程思维去写Go代码”。看到这个题目大家不禁要问:究竟什么是Go语言编程思维呢?关于什么是Go语言变成思维其实并没有官方说法。这里要和大家交流的内容都是基于Go诞生七年多以来我个人对Go的设计者、Go team以及Go主流社区的观点和代码行为的整理、分析和总结。希望通过我的这次“抛砖引玉”,让在座的Gopher们对“Go语言编程思维”有一个初步的认知,并在日常开发工作中遵循Go语言的编程思维,写出idiomatic的Go代码。

二、编程语言与编程思维

1、大师的观点

在人类自然语言学界有一个很著名的假说:”萨丕尔-沃夫假说“,这个假说的内容是这样的:

语言影响或决定人类的思维方式("Language inuences/determines thought" - Sapir-Whorf hypothesis )

说到这个假说,我们不能不提及在2017年初国内上映了一部口碑不错的美国科幻大片《降临》,这部片子改编自雨果奖获得者华裔科幻小说家Ted姜的《你一生的故事》,片中主线剧情的理论基础就是就是“萨丕尔-沃夫假说”。更夸张的是片中直接将该假说应用到外星人语言上,将其扩展到宇宙范畴^_^。片中的女主作为人类代表与外星人沟通,并学会了外星语言,从此思维大变,拥有了预知未来的“超能力”。由此我们可以看出“选择对一门语言是多么的重要”。

奇妙的是,在编程语言界,有位大师级人物也有着与”萨丕尔-沃夫假说”异曲同工的观点和认知。他就是首届图灵奖得主、著名计算机科学家Alan J. Perlis(艾伦·佩利)。他从另外一个角度提出了:

“不能影响到你的编程思维方式的编程语言不值得去学习和使用”

A language that doesn't aect the way you think about programming is not worth knowing.

2、现实中的“投影”

从上述大师们的理论和观点,我们似乎看到了语言与思维之间存在着某种联系。那么两者间的这种联系在真实编程世界中的投影又是什么样子的呢?我们来看一个简单的编程问题:

【问题: 素数筛】

  问题描述:素数是一个自然数,它具有两个截然不同的自然数除数:1和它本身。 要找到小于或等于给定整数n的素数。针对这个问题,我们可以采用埃拉托斯特尼素数筛算法。
  算法描述:先用最小的素数2去筛,把2的倍数剔除掉;下一个未筛除的数就是素数(这里是3)。再用这个素数3去筛,筛除掉3的倍数... 这样不断重复下去,直到筛完为止。

img{512x368}
算法动图

下面是该素数筛算法的不同编程语言的实现版本。

C语言版本:

【sieve.c】

void sieve() {
        int c, i,j,numbers[LIMIT], primes[PRIMES];

        for (i=0;i<LIMIT;i++){
                numbers[i]=i+2; /*fill the array with natural numbers*/
        }

        for (i=0;i<LIMIT;i++){
                if (numbers[i]!=-1){
                        for (j=2*numbers[i]-2;j<LIMIT;j+=numbers[i])
                                numbers[j]=-1; /*sieve the non-primes*/
                }
        }

        c = j = 0;
        for (i=0;i<LIMIT&&j<PRIMES;i++) {
                if (numbers[i]!=-1) {
                        primes[j++] = numbers[i]; /*transfer the primes to their own array*/
                        c++;
                }
        }

        for (i=0;i<c;i++) printf("%d\n",primes[i]);
}

Haskell版本:

【sieve.hs】

sieve [] = []
sieve (x:xs) = x : sieve (filter (\a -> not $ a `mod` x == 0) xs)

n = 100
main = print $ sieve [2..n]

Go语言版本:

【sieve.go】

func generate(ch chan<- int) {
    for i := 2; ; i++ {
        ch <- i // Send 'i' to channel 'ch'.
    }
}

func filter(src <-chan int, dst chan<- int, prime int) {
    for i := range src { // Loop over values received from 'src'.
        if i%prime != 0 {
            dst <- i // Send 'i' to channel 'dst'.
        }
    }
}

func sieve() {
    ch := make(chan int) // Create a new channel.
    go generate(ch)      // Start generate() as a subprocess.
    for {
        prime := <-ch
        fmt.Print(prime, "\n")
        ch1 := make(chan int)
        go filter(ch, ch1, prime)
        ch = ch1
    }
}

  • C版本的素数筛程序是一个常规实现。它定义了两个数组:numbers和primes,“筛”的过程在numbers这个数组中进行(纯内存修改),非素数的数组元素被设置为-1,便于后续提取;
  • Haskell版本采用了函数递归的思路,通过 “filter操作集合”,用谓词(过滤条件)\a -> not $ a mod x == 0;筛除素数的倍数,将未筛除的数的集合作为参数传递归递给下去;
  • Go版本的素数筛实现采用的是goroutine的并发组合。程序从2开始,依次为每个素数建立一个goroutine,用于作为筛除该素数的倍数。ch指向当前最新输出素数所位于的筛子goroutine的源channel,这段代码来自于Rob Pike的一次关于concurrency的分享slide。

img{512x368}

3、思考

通过上述这个现实中的问题我们可以看到:面对同一个问题,来自不同编程语言的程序员给出了思维方式截然不同的解决方法:C的命令式思维、Haskell的函数式思维和Go的并发思维。这一定程度上印证了前面的假说:编程语言影响编程思维。

Go语言诞生较晚(2007年设计、2009年发布Go1),绝大多数Gopher(包括我在内)第一语言都不是Go,都是“半路出家”从其他语言转过来的,诸如:C、C++、JavaPython等,甚至是Javascript、HaskellLisp等。由于Go语言上手容易,在转Go的初期大家很快就掌握了Go的语法。但写着写着,就是发现自己写的代码总是感觉很别扭,并且总是尝试在Go语言中寻找自己上一门语言中熟悉的语法元素;自己的代码风格似乎和Go stdlib、主流Go开源项目的代码在思考角度和使用方式上存在较大差异。而每每看到Go core team member(比如:rob pike)的一些代码却总有一种醍醐灌顶的赶脚。这就是我们经常说的go coding in c way、in java way、in python way等。出现这种情况的主要原因就是大脑中的原有语言的思维方式在“作祟”。

我们学习和使用一门编程语言,目标就是要用这门语言思维方式去Coding。学习Go,就要用Go的编程思维去写Go代码,而不是用其他语言的思维方式。

4、编程语言思维的形成

人类语言如何影响人类思维这个课题自然要留给人类语言学家去破解。但编程语言如何影响编程思维,每个程序员都有着自己的理解。作为一个有着十几年编程经验的程序员,我认为可以用下面这幅示意图来解释一门编程语言思维的形成机制:

img{512x368}

决定编程语言思维的根本在于这门编程语言的价值观!什么是价值观?个人认为:一门编程语言的价值观就是这门语言的最初设计者对程序世界的认知。不同编程语言的价值观不尽相同,导致不同编程语言采用不同的语法结构,不同语言的使用者拥有着不同的思维方式,表现出针对特定问题的不同的行为(具现为:代码设计上的差异和代码风格上的不同),就像上面素数筛那样。比如:

C的价值观摘录:

- 相信程序员:提供指针和指针运算,让C程序员天马行空的发挥
- 自己动手,丰衣足食:提供一个很小的标准库,其余的让程序员自造
- 保持语言的短小和简单
- 性能优先

C++价值观摘录:

- 支持多范式,不强迫程序员使用某个特定的范式
- 不求完美,但求实用(并且立即可用)

此外,从上述模型图,我们可以看出思维和结构影响语言应用行为,这是语言应用的核心;同时存在一个反馈机制:即语言应用行为会反过来持续影响/优化语言结构。我们常用冰山表示一个事物的表象与内涵。如果说某种语言的惯用法idiomatic tips或者best practice这些具体行为是露出水面上的冰山头部,那么价值观和思维方式就是深藏在水面以下的冰山的基座。

三、Go语言价值观的形成与Go语言价值观

从上述模型来看,编程语言思维形成的主导因素是这门编程语言的价值观,因此我们首先来看一下Go语言价值观的形成以及Go语言价值观的具体内容。

Go语言的价值观的形成我觉得至少有三点因素。

1、语言设计者&Unix文化

Go语言价值观形成是与Go的初期设计者不无关系的,可以说Go最初设计者主导了Go语言价值观的形成!这就好比一个企业的最初创始人缔造企业价值观和文化一样。

img{512x368}

图中是Go的三位最初设计者,从左到右分别是罗伯特·格瑞史莫、罗伯·派克和肯·汤普逊。Go初期的所有features adoption是需要三巨头达成一致才行。三位设计者有一个共同特征,那就是深受Unix文化熏陶。罗伯特·格瑞史莫参与设计了Java的HotSpot虚拟机和Chrome浏览器的JavaScript V8引擎,罗博·派克在大名鼎鼎的bell lab侵淫多年,参与了Plan9操作系统、C编译器以及多种语言编译器的设计和实现,肯·汤普逊更是图灵奖得主、Unix之父。关于Unix设计哲学阐述最好的一本书莫过于埃瑞克.理曼德(Eric S. Raymond)的《UNIX编程艺术》了,该书中列举了很多unix的哲学条目,比如:简单、模块化、正交、组合、pipe、功能短小且聚焦等。三位设计者将Unix设计哲学应用到了Go语言的设计当中,因此你或多或少都能在Go的设计和应用中找到这些哲学的影子。

2、遗传基因

Go并发模型CSP理论的最初提出者Tony Hoare曾提出过这样一个观点:

The task of the programming language designer " is consolidation not innovation ". (Tony Hoare, 1973).
编程语言设计者的任务不是创新,而是巩固。

img{512x368}

和其他语言一样,Go也是站在巨人肩膀上的。这种基因继承,不仅仅是语法结构的继承,还有部分价值观的继承和进一步认知改进。当然不可否认的是Go也有自己的微创新,比如: implicit interface implementation、首字母大小写决定visibility等。虽然不受学院派待见,但把Go的这些微创新组合在一起,你会看到Go迸发出了强大的表现力。

3、面向新的基础设施环境和大规模软件开发的诸多问题

有一种开玩笑的说法:Go诞生于C++程序的漫长compile过程中。如果c++编译很快,那么上面的Go语言三巨头也没有闲暇时间一起喝着咖啡并讨论如何设计一门新语言。

面对时代变迁、面对新的基础设施环境、多核多处理器平台的出现,很多传统语言表现出了“不适应”,这直接导致在开发大规模软件过程中出现了各种各样的问题,比如:构建缓慢、依赖失控、代码风格各异、难用且复杂无法自动化的工具、跨语言构建难等。Go的设计初衷就是为了面向新环境、面向解决问题的。虽然这些问题不都是能在语言层面解决的,但这些环境和问题影响了设计者对程序世界的认知,也就影响了Go的价值观。

4、Go语言的价值观

在明确了Go价值观的形成因素后,我认为Go语言的价值观至少包含以下几点:

 - Overall Simplicity 全面的简单
 - Orthogonal Composition 正交组合
 - Preference in Concurrency 偏好并发

用一句话概括Go的价值观(也便于记忆):

Go is about orthogonal composition of simple concepts with preference in concurrency.
Go是在偏好并发的环境下的简单概念/事物的正交组合

无论是Go语言设计还是Go语言使用,都受到上述价值观的影响。接下来我们逐个来看一下Go语言价值观主导下的Go语言编程思维,并看看每种编程思维在语言设计、标准库实现以及主流Go开源项目中的应用体现。我将按“价值观” -> “(价值观下的)语言设计” -> “编程思维” -> “编程思维体现”的顺序展开。

四、Overall Simplicity

Go的第一个价值观就是”全面简单”。

图灵奖获得者迪杰斯特拉说过:”简单和优雅不受欢迎,那是因为人们要想实现它们需要更努力地工作,更多自律以及领会更多的教育。” 而Go的设计者们恰恰在语言设计初期就将复杂性留给了语言自身的设计和实现阶段,留给了Go core team,而将简单留给了gopher们。因此,Simplicity价值观更多地体现在了Go语言设计层面。 这里简单列举一些:

- 简洁、正规的语法:大大降低Go入门门槛,让来自其他语言的初学者可以轻松使用Go语言;
- 仅仅25个keyword:主流编程语言中最简单的,没有之一;
-  “一种”代码写法、尽可能减少程序员付出;
- 垃圾回收GC: 降低程序员在内存管理方面的心智负担;
- goroutine:提供最简洁的并发支持;
- constants:对传统语言中常量定义和使用方法做进一步简化;
- interface:纯方法集合,纯行为定义,隐式实现;
- package:Go程序结构层面的唯一组织形式,它将设计、语法、命名、构建、链接和测试都聚于一包中,导入和使用简单。

如今,Go语言的简单已经从自身设计扩展到Go应用的方方面面,但也正是由于在语言层面已经足够简单了,因此在应用层面,“简单”体现的反倒不是很明显,更加顺其自然。接下来,我总结整理几个在“全面简单”价值观下形成的Go编程思维,我们一起看一下。

1、short naming thought(短命名思维)

在gofmt的帮助下,Go语言一统coding style。在这样的一个情形下,naming成了gopher们为数不多可以“自由发挥”的空间了。但对于naming,Go有着自己的思维:短命名。即在并不影响readablity的前提下,尽可能的用长度短小的标识符,于是我们经常看到用单个字母命名的变量,这与其他一些语言在命名上的建议有不同,比如Java建议遵循“见名知义”的命名原则。

Go一般在上下文环境中用最短的名字携带足够的信息,我们可以对比一下Java和Go:

   java    vs. go

  "index" vs. "i"
  "value" vs. "v"

除了短小,Go还要求尽量在一定上下文中保持命名含义的一致性,比如:在一个上下文中,我们声明了两个变量b,如果第一个b表意为buf,那么后续的b也最好是这个含义。

在命名短小和一致性方面,stdlib和知名开源项目为我们做出表率。我们统计一下Go标准库中标识符使用频率,可以看到大量单字母命名的变量标识符占据top30:

cat $(find $GOROOT -name '*.go') | indents | sort | uniq -c | sort -nr | sed 30q
          60224 v
          42444 err
          38012 t
          33386 x
          33302 i
          33277 b
          27943 p
          25121 s
          21228 n
          20831 r
          20634 _
          19236 c
          17056 y
          12850 f
          12834 a
          ... ...

细致分析了一下stdlib中常见短变量名字所代表的含义(见代码后的注释),stdlib在一致性方面做的还是不错的,当然也有例外。

        [v, k, i]

        // loop varible
        for i, v := range s {
        for k, v := range m {
        for v := range r { // channel

        // if、switch/case clause varible
        if v := mimeTypes[ext]; v != "" {
        switch v := ptr.Elem(); v.Kind() {
        case v := <-c:

        v := reflect.ValueOf(x) // result of reflect.Value()

        [t]

        t := time.Now() // time
        t := &Timer{ // timer
        if t := md.typemap[off]; t != nil { // type

        [b]

        b := make([]byte, n) // bytes slice
        b := new(bytes.Buffer) // bytes.Buffer

2、minimal thought(最小思维)

码农们是苦逼的,每天坐在电脑前一坐就是10多个小时,自己的“业余”时间已经很少了。Go语言的设计者在这方面做的很“贴心”,考虑到为了让男Gopher能有时间撩妹,女Gopher能有时间傍帅哥,Go语言倡导minimal thought,即尽可能的降低gopher们的投入。这种思维体现在语言设计、语言使用、相关工具使用等多个方面。比如:

  • 一种代码风格:程序员们再也无需为coding style的个人喜好而争论不休了,节省下来的时间专心做自己喜欢的事情:)
  • “一种”代码写法(或提供最少的写法、更简单的写法):你会发现,面对一个问题,大多数gopher们给出的go实现方式都类似。这就是Go“一种代码写法”思维的直接体现。Go在语法结构层面没有提供给Gopher很大的灵活性。Go is not a “TMTOWTDI — There’s More Than One Way To Do It”。这点与C++、Ruby有着很大不同。
  • 显式代码(obvious),而不是聪明(clever)代码:Go提倡显而易见、可读性好的代码,而非充满各种技巧或称为“炫技”的所谓“聪明”代码。纵观stdlib、kubernetes等go代码库,都是很obvious(直观)的go code,clever code难觅踪迹。这样一来,别人写的代码,你可以轻松地看懂(为你节省大量时间和精力)。这也是Go代码中clever code比例远远小于其他主流语言的原因,Go不是炫技的舞台。

C++程序员看到这里是不是在“抹眼泪”,这里并非黑C++,C++的复杂和多范式是客观的,C++98标准和C++17标准的差异甚至可以用“两门语言”来形容,用泛型的代码和不用泛型的代码看起来也像是两门完全不同的语言,这种心智负担之沉重可想而知。

接下来,我们看看minimal thought在语言设计和应用中的体现。

1) “一种”循环: for

Go语言仅仅提供了一种用于“循环逻辑”的关键字:for。在其他语言中的各种用于循环逻辑的关键字,比如while, do-while等,在go中都可以通过for模拟实现。

- 常规
  for i := 0; i < count; i++ {}

- "while"
  for condition { }

- "do-while"
  for { // use "for-break" instead
        doSomething()
        if condition { break }
  }

- iterator loop
  for k, v := range f.Value {}

- dead loop
  for {}

2) “一种”constant

前面说过Go设计者是十分体贴的,这种体贴体现在很多不起眼的细节上,比如对传统语言中constant声明和使用的优化。

Go语言中constants只是数字,无论是整型还是浮点型都可以直接写成数字,无需显式地赋给类型:

  const incomingQueueLength = 25

  const (
      http2minMaxFrameSize = 1 << 14
      http2maxFrameSize    = 1<<24 - 1
  )

  const PI = 3.1415928
  const e = 1E6

参与计算的constant无需显式算术转换,而是由编译器自动确定语句中constant的承载类型:

  const a = 10080
  var c int32 = 99
  d := c + a
  fmt.Printf("%T\n", d) //int32
  fmt.Printf("%T\n", a) //int

3) “一种”错误处理方法

C++之父Bjarne Stroustrup说过:“世界上有两类编程语言,一类是总被人抱怨诟病的,而另外一类是无人使用的”。Go语言自其出生那天起,就因错误处理机制看起来似乎有些过时、有些简单而被大家所诟病,直至今天这种声音依旧存在。因为Go仅仅提供了一种基于值比较的简单的错误处理方法。但就是这样的错误处理方法也恰恰是Go设计者simplicity价值观的体现。Go设计者认为如果像其他一些主流语言那样,将exception的try-catch-finally的机制与语言的控制结构耦合在一起,将势必大大增加语言的复杂性,这与simplicity的价值观是背道而驰的。简单的基于值比较的error处理方法可以让使用者更重视每一个error并聚焦于错误本身。显式地去处理每一个error,让gopher对代码更有自信。并且在这种机制下,错误值和其他类型的值地位是一样的,错误处理代码也是普通代码,并无特殊之处,无特殊化处理,无需增加语言复杂性。

这些年来,gopher们也初步探索出了这种错误处理方法的常见处理模式,我们以stdlib中识别出的error handling模式为例:

a) 最常见的

在外部无需区分返回的错误值的情况下,可以在内部通过fmt.Errorf或errors.New构造一个临时错误码并返回。这种错误处理方式可以cover 80%以上情形:

    callee:
    return errors.New("something error")

    or

    return fmt.Errorf("something error: %s", "error reason")

  caller:
    if err != nil {... }

b) 导出的Error变量

当外部需要区分返回的错误值的,比如这里我要进行一个io调用,后续的操作逻辑需要因io调用的返回错误码的不同而异,我们使用导出的error变量:

  // io/io.go
  var ErrShortWrite = errors.New("short write")
  var ErrShortBuffer = errors.New("short buffer")

  if err := doSomeIO(); err == io.ErrShortWrite { ... }

c) 定义新的错误类型实现定制化错误上下文

上面的导出Error变量中包含的error context信息和信息形成机制太过简单,当我们要定制error context时, 我们可以定义一个新的Error type。之后通过针对error interface value的type assertion or type switch得到真实错误类型并访问error context:

  // encoding/json/decode.go
  type UnmarshalTypeError struct {
      Value  string       // description of JSON value - "bool", "array", "number -5"
      Type   reflect.Type // type of Go value it could not be assigned to
      Offset int64        // error occurred after reading Offset bytes
      Struct string       // name of the struct type containing the field
      Field  string       // name of the field holding the Go value
  }

  func (e *UnmarshalTypeError) Error() string {
      ... ...
      return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
  }

  if serr, ok := err.(*UnmarshalTypeError); ok {
     //use serr to access context in UnmarshalTypeError
     ... ...
  }

不过这样的用法并不推荐也并不多见,在stdlib、kubernetes中,虽然都有自定义的exported error type,但是却很少在外部通过type assertion直接访问其内部error context字段,那标准库是怎么判断error差别的呢?

**d) 包含package中error公共行为特征的Error interface type

在标准库中,我们可以发现这样一种错误处理方式:将某个包中的Error Type归类,统一提取出一些公共行为特征,并且将这些公共行为特征(behaviour)放入一个公开的interface type中。以stdlib中的net package为例。net package将包内的所有错误类型的公共特征抽象放入”Error”这个error type中。外部使用时,通过这个公共interface获取具体错误的特征:

//net/net.go
  type Error interface {
      error
      Timeout() bool   // Is the error a timeout?
      Temporary() bool // Is the error temporary?
  }

net/http/server.go中的使用举例:

  rw, e := l.Accept()
  if e != nil {
      if ne, ok := e.(net.Error); ok && ne.Temporary() {
         ... ..
      }
      ... ...
  }

OpError是net packge中的一个自定义error type , 它实现了Temporary interface, 可以被外部统一用Error的method判断是否是Temporary或timeout error特征:

  //net/net.go
  type OpError struct {
      ... ...
      // Err is the error that occurred during the operation.
      Err error
  }

  type temporary interface {
      Temporary() bool
  }

  func (e *OpError) Temporary() bool {
    if ne, ok := e.Err.(*os.SyscallError); ok {
        t, ok := ne.Err.(temporary)
        return ok && t.Temporary()
    }
    t, ok := e.Err.(temporary)
    return ok && t.Temporary()
  }

**e) 通过一些公开的error behaviour function对error behaviour进行判断

我们在标准库中还能看到一种判断error behavior的方法,那就是通过一些公开的error behaviour function。比如:os包暴露的IsExist等函数:

  //os/error.go

  func IsExist(err error) bool {
      return isExist(err)
  }
  func IsNotExist(err error) bool { ... }
  func IsPermission(err error) bool { ... }

  例子:

    f, err := ioutil.TempFile("", "_Go_ErrIsExist")
    f2, err := os.OpenFile(f.Name(), os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
    if os.IsExist(err) {
        fmt.Println("file exist")
        return
    }

顺便在这里提一下Go关于error type和variable的命名方式:

 错误类型: xxxError

  //net/net.go
  type OpError struct { ... }
  type ParseError struct { ... }
  type timeoutError struct{}

导出的错误变量: ErrXxx

  //io/io.go
  var ErrShortWrite = errors.New("short write")
  var ErrNoProgress = errors.New("multiple Read calls return no data or error")

很多人抱怨,当前Go提供的error handling方案让gopher可以很容易地写出如下面所示的不优雅代码:

  var err error
  err = doSomethingA()
  if err != nil {
      return err
  }

  err = doSomethingB()
  if err = nil {
      return err
  }

  err = doSomethingC()
  if err = nil {
      return err
  }
  ... ...

代码中大量重复着if err!= nil { return err} 这段snippet。但是如果你全面浏览过Go标准库中的代码,你会发现像上面这样的代码并不多见。Rob Pike曾经在《errors are values》一文中针对这个问题做过解释,并给了stdlib中的一些消除重复的方法:那就是将error作为一个内部状态:

  //bufio/bufio.go
  type Writer struct {
      err error
      buf []byte
      n   int
      wr  io.Writer
  }
  func (b *Writer) Write(p []byte) (nn int, err error) {
      if b.err != nil {
          return nn, b.err
      }
      ... ...
  }

  //writer_demo.go
  buf := bufio.NewWriter(fd)
  buf.WriteString("hello, ")
  buf.WriteString("gopherchina ")
  buf.WriteString("2017")
  if err := buf.Flush() ; err != nil {
      return err
  }

error handling的具体策略要根据实际情况而定。stdlib面向的”业务域”相对”狭窄”,像bufio.Write可以采用上面的方法解决,但是对于做业务应用的gopher来讲,业务复杂多变,错误处理没有绝对的模式,需根据上下文不同而具体设计。但如果一个函数中上述snippet过多,很可能是这个函数或方法的职责过多导致,重构是唯一出路。

五、Orthogonal Composition

正交组合是我总结出来的第二个Go语言的价值观。如果说上一个价值观聚焦的是Go程序提供的各种小概念实体或者说”零件”的话,那么Composition就是在考虑如何将这些”零件”联系到一起,搭建程序的静态骨架。

在Go语言设计层面,Go设计者为gopher提供了正交的语法元素,供后续组合使用,包括:

  • Go语言无类型体系(type hierarchy),类型定义正交独立;
  • 方法和类型的正交性: 每种类型都可以拥有自己的method set;
  • interface与其实现之间无”显式关联”;

正交性为”组合”策略的实施奠定了基础,提供了前提。Rob Pike曾说过: “If C++ and Java are about type hierarchies and the taxonomy(分类)of types, Go is about composition.”。组合是搭建Go程序静态结构的主要方式。“组合”的价值观贯穿整个语言设计和语言应用:

  • 类型间的耦合方式直接影响到程序的结构;
  • Go语言通过“组合”构架程序静态结构;
  • 垂直组合(类型组合):Go通过 type embedding机制提供;
  • 水平组合:Go通过interface语法进行“连接”。

interface是水平组合的关键,好比程序肌体上的“关节”,给予连接“关节”的两个部分各自“自由活动”的能力,而整体上又实现了某种功能。

1、vertical composition thought(垂直组合思维)

传统OO语言都是通过继承的方式建构出自己的类型体系的,但Go语言中并没有类型体系的概念。Go语言通过类型的垂直组合而不是继承让单一类型承载更多的功能。由于不是继承,那么也就没有了所谓“父子类型”的概念,也没有向上、向下转型(type casting);被嵌入的类型也不知道将其嵌入的外部类型的存在。调用Method时,method的匹配取决于方法名字,而不是类型。

Go语言通过type embedding实现垂直组合。组合方式莫过于以下这么几种:

a) construct interface by embedding interface

  type ReadWriter interface {
      Reader
      Writer
  }

通过在interface中嵌入interface type name,实现接口行为聚合,组成大接口。这种方式在stdlib中尤为常用。

b) construct struct by embedding interface

  type MyReader struct {
      io.Reader // underlying reader
      N int64   // max bytes remaining
  }

c) construct struct by embedding struct

  // sync/pool.go
  type poolLocal struct {
      private interface{}   // Can be used only by the respective P.
      shared  []interface{} // Can be used by any P.
      Mutex                 // Protects shared.
      pad     [128]byte     // Prevents false sharing.
  }

在struct中嵌入interface type name和在struct嵌入struct,都是“委派模式(delegate)”的一种应用。在struct中嵌入interface方便快速构建满足某一个interface的dummy struct,方便快速进行unit testing,仅需实现少数需要的接口方法即可,尤其是针对Big interface时。

struct中嵌入struct,被嵌入的struct的method会被提升到外面的类型中,比如上述的poolLocal struct,对于外部来说它拥有了Lock和Unlock方法,但是实际调用时,method调用实际被传给poolLocal中的Mutex实例。

2、small interface thought(小接口思维)

interface是Go语言真正的魔法。前面提到过,interface好比程序肌体的骨架关节,上下连接着骨架部件。interface决定了Go语言中类型的水平组合方式。interface与其实现者之间的关系是隐式的,无需显式的”implements”声明(但编译器会做静态检查);interface仅仅是method集合,而method和普通function一样声明,无需在特定位置。

在Go语言中,你会发现小接口(方法数量在1~3)定义占据主流。

  // builtin/builtin.go
  type error interface {
      Error() string
  }

  // io/io.go
  type Reader interface {
      Read(p []byte) (n int, err error)
  }

  // net/http/server.go
  type Handler interface {
      ServeHTTP(ResponseWriter, *Request)
  }

  type ResponseWriter interface {
      Header() Header
      Write([]byte) (int, error)
      WriteHeader(int)
  }

我统计了一下stdlib、k8s和docker里面的interface定义,画出了下面这幅接口个数与接口中method个数关系的折线图:

img{512x368}

小接口方法少,职责单一;易于实现和测试,通用性强(如:io.Reader和Writer),易于组合(如:io.Reader)。不过要想在业务领域定义出合适的小接口,还是需要对问题域有着透彻的理解的。往往无法定义出小接口,都是由于对领域的理解还不到位,没法抽象到很高的程度所致。

3、horizontal composition thought(水平组合思维)

有了小接口,后续主要关注如何通过接口进行“连接”的方式实现水平组合,以解决大问题、复杂的问题。通过interface进行组合的一种常见方法就是:通过接受interface类型参数的普通function进行组合。

以下几种具体形式:

a) 基本形式

接受interface value作为参数是水平组合的基本形式:

形式:someFunc(interface value parameter)

隐式的interface实现会不经意间满足:依赖抽象、里氏替换原则、接口隔离等原则,这在其他语言中是需要很”刻意”的设计谋划的,但在Go interface来看,一切却是自然而然的。

  func ReadAll(r io.Reader) ([]byte, error)
  func Copy(dst Writer, src Reader) (written int64, err error)

b) wrapper function

形式:接受interface类型参数,并返回与其参数类型相同的返回值

  // Wrapper function:
  func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }

  type LimitedReader struct {
      R Reader // underlying reader
      N int64  // max bytes remaining
  }
  func (l *LimitedReader) Read(p []byte) (n int, err error) {}

  // Usage:
  r := strings.NewReader("some io.Reader stream to be read\n")
  lr := io.LimitReader(r, 4)
  if _, err := io.Copy(os.Stdout, lr); err != nil {
      log.Fatal(err)
  }
  // Output: some

LimitReader是一个wrapper function,它在r的外面再包裹上LimitedReader。通过wrapper function将NewReader和LimitedReader 的两者巧妙的组合在了一起。这样当我们采用包装后的reader去Read时,返回的是受到Limitedreader限制的内容了:即只读取了前面的4个字节:”some”。

c) wrapper function chain

由于wrapper function返回值类型与parameter类型相同,因此wrapper function可以组合一个chain,形式如下:

形式:wrapperFunc(wrapperFunc(wrapperFunc(...)))

我们定义一个wrapper function:CapReader,用于将从reader读取的数据变为大写:

  func CapReader(r io.Reader) io.Reader {
      return &capitalizedReader{r: r}
  }

  type capitalizedReader struct {
      r io.Reader
  }

  func (r *capitalizedReader) Read(p []byte) (int, error) {
      n, err := r.r.Read(p)
      if err != nil {
          return 0, err
      }

      q := bytes.ToUpper(p)
      for i, v := range q {
          p[i] = v
      }
      return n, err
  }

将多个wrapper function串在一起:

  s := strings.NewReader("some io.Reader stream to be read\n")
  r := io.TeeReader(CapReader(io.LimitReader(s, 4)), os.Stdout)
  b, _ := ioutil.ReadAll(r) //SOME
  fmt.Println(len(b))       //4

可以看到例子中,我们将TeeReader、CapReader、LimitedReader、strings Reader等组合到了一起,实现了读取前四个字节,将读取数据转换为大写并输出到标准输出的功能。

**d) adapter function type **

adapter function type是一个辅助水平组合实现的“工具”。adapter function type将一个普通function转换为自己的类型,同时辅助快速实现了某个“one-method” interface。 adapter function type的行为模式有些像电影中的“僵尸” – 咬别人一口就可以将别人转化为自己的同类。最著名的僵尸类型莫过于http.HandlerFunc了:

  type Handler interface {
      ServeHTTP(ResponseWriter, *Request)
  }

  type HandlerFunc func(ResponseWriter, *Request)

  func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
      f(w, r)
  }

  // Usage: use HandlerFunc adapts index function to an implemenation type of Handler interface.
  func index(w http.ResponseWriter, r *http.Request) {
      fmt.Fprintf(w, "Welcome!")
  }

  http.ListenAndServe(":8080", http.HandlerFunc(index))

可以看到通过HandlerFunc,我们可以将普通function index快速转化为满足Handler interface的type。一旦转化ok,便可以通过interface进行组合了。

**e) middleware composition **

middleware这个词的含义可大可小,在Go Web编程中,常常指的是一个满足Handler interface的HandlerFunc类型实例。实质上:

middleware =  wrapper function + adapter function type

我们可以看一个例子:

  func logHandler(h http.Handler) http.Handler {
      return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
          t := time.Now()
          log.Printf("[%s] %q %v\n", r.Method, r.URL.String(), t)
          h.ServeHTTP(w, r)
      })
  }

  func authHandler(h http.Handler) http.Handler {
      return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
          err := validateAuth(r.URL.Query().Get("auth"))
          if err != nil {
              http.Error(w, "bad auth param", http.StatusUnauthorized)
              return
          }
          h.ServeHTTP(w, r)
      })
  }

  func main() {
      http.ListenAndServe(":8080", logHandler(authHandler(http.HandlerFunc(index))))
  }

wrapper function(如:logHandler、authHandler)内部利用 adapter function type转化了一个普通function,并返回实现了Handler interface的HandlerFunc类型实例。

六、Preference in Concurrency

Go语言的第三个价值观是偏好并发。如果说interface和组合决定了程序的静态结构组成的话,那么concurrency则影响着程序在执行阶段的动态运行结构。从某种意义上说,Go语言就是关于concurrency和interface的设计!

并发不是并行(paralell),并发是关于程序结构的,而不是关于性能的。并发让并行更easy,并且通常性能更好;对于程序结构来说,concurrency是一个比interface组合更大的概念。并发是一种在程序执行层面上的组合:goroutines各自执行特定的工作,通过channels+select将goroutines连接起来。原生对并发的支持,让Go语言更适应现代计算环境。并发的存在鼓励程序员在程序设计时进行独立计算的分解。

在语言层面,Go提供了三种并发原语:

  • goroutines提供并发执行, 它是Go runtime调度的基本单元;goroutine实现了异步编程模型的高效,但却允许你使用同步范式编写代码,降低心智负担;goroutines被动态地多路复用到系统核心线程上以保证所有goroutines的正常运行。

  • channels用于goroutines之间的通信和同步;channel是goroutines间建立联系的主要途径或者说goroutine通过channel耦合/组合在一起,这一点channel的功用有点像Unix pipe。

  • select可以让goroutine同时协调处理多个channel操作。

1、concurrency thought(并发思维)

我将“偏好并发”价值观下的思维统称为“并发思维”。并发思维的核心依旧是组合!

采用并发思维进行程序动态结构设计,需要识别和分解出独立的计算单元放入Goroutines执行,并使用channel/select建立Goroutines之间的联系。计算单元的拆解是并发程序设计的重点,拆解没有统一规则,因业务域不同而异,例如:素数筛实现为每个素数建立一个goroutine以筛除素数的倍数。

不过我们可以从建立Goroutines间的“联系”的角度来看一些常见的goroutines间的“关系”模式。我们可以从“退出机制”和“通信联系”两大方面出发考虑。

a) “detached” goroutine

所谓分离的goroutine,即不需要关心它的退出,相当于与父goroutine间“无关系”。这类goroutines启动后与其创建者彻底分离(detached),生命周期与程序生命周期相同。通常,这类goroutine在后台执行一些特定任务,如:monitor、watcher等。其实现通常采用for-select代码段形式;以timer或event驱动。

Go应用中内置的GC goroutine就是这种类型的:

// runtime/mgc.go
  go gcBgMarkWorker(p) // each P has a background GC G.

  func gcBgMarkWorker(_p_ *p) {
      gp := getg()

      for {
        ... ...
      }
  }

b) “parent-child” goroutine

这类goroutine与detached goroutine正相反,parent需要通知并等待child退出。如果仅通知并等待一个child,我们可以这样做:

parent:

  quit := make(chan string)
  go child(quit)

child:

  select {
    case c := <-workCh:
    // do something
    case <-quit:
    // do some cleanup
    quit<-"done"
  }

parent:

  quit<-"quit"
  <-quit

当需要同时通知多个child goroutine quit时,我们可以通过channel close来实现:

parent:

  quit := make(chan struct{})
  for ... {
    go child(quit) // several child goroutines
  }

child:

  select {
    case c := <-workCh: // do something
    case <-quit: // do some cleanup
    return
  }

parent:

  close(quit)
  time.Sleep(time.Second * 30)

如果parent要获得child的退出状态值,可以自定义quit channel中的元素类型:

  type ExitStatus interface {
      Status() int
  }

  type IntStatus int // an adapter
  func (n IntStatus)Status() int {
    return int(n)
  }

  quit := make(chan ExitStatus) // for each child goroutine

child:

  quit <- IntStatus(2017)

parent:

  s := <-quit
  fmt.Println(s.Status()) //2017

c) service handle

一些goroutine在程序内部提供特定service,这些goroutine使用channel作为service handle,其他goroutine通过service handle与其通信。

比如:我们经常使用的time.After返回一个service handle:

  //time/sleep.go
  func After(d Duration) <-chan Time {
      return NewTimer(d).C
  }

对应的service goroutine就是runtime中的timer service goroutine:

  // runtime/time.go
  func timerproc() {
    timers.gp = getg()
    for {
      ... ...
    }
  }

编写此类service goroutine时,需要考虑对于“慢消费者”service goroutine应该如何处置:阻塞还是丢弃。timer service goroutine使用的是buffered channel(size=1),并在向channel发送消息时通过select做了一个判断。如果channel buffer满了,则丢弃这次timer事件。

如果我们要同时处理来自不同service goroutine的handle,那么可以使用service handles aggregation,见下面例子:

比如:我们从wechat、weibo、短信渠道获取msg:

  type msg struct {
      content string
      source  string
  }

  func wechatReceiver() <-chan *msg {
      c := make(chan *msg)
      go func() {
          c <- &msg{"wechat1", sourceWechat}
          c <- &msg{"wechat2", sourceWechat}
          c <- &msg{"wechat3", sourceWechat}
      }()

      return c
  }

  func weiboReceiver() <-chan *msg {...}
  func textmessiageReceiver() <-chan *msg {...}

我们需要把这些handle聚合起来统一处理,我们通过一个aggregation function来做。对于不固定数量handles的聚合,用goroutine来聚合(非常类似于unix pipe chain):

  func serviceAggregation(ins ...<-chan *msg) <-chan *msg {
      out := make(chan *msg)
      for _, c := range ins {
          go func(c <-chan *msg) {
              for v := range c {
                  out <- v
              }
          }(c)
      }
      return out
  }

  c := serviceAggregation(weiboReceiver(), wechatReceiver(), textmessageReceiver())
  m := <-c // 获取message并处理

对于固定数量handles聚合,用select就可以实现:

  func serviceAggregation(weibo, wechat, textmessage <-chan *msg) <-chan *msg {
      out := make(chan *msg)

      go func(out chan<- *msg) {
          for {
              select {
              case m := <-weibo:
                  out <- m
              case m := <-wechat:
                  out <- m
              case m := <-textmessage:
                  out <- m
              }
          }
      }(out)
      return out
  }
  c := serviceAggregation(weiboReceiver(), wechatReceiver(), textmessageReceiver())
  m := <-c // 获取message并处理

d) dispatch-and-mix goroutines

在“微服务”时代,我们在处理一个请求时经常调用多个外部微服务并综合处理返回结果:

  func handleRequestClassic() {
    r1 := invokeService1()
    //handle result1
    r2 := invokeService2()
    //handle result2
    r3 := invokeService3()
    //handle result3
  }

上述例子中的问题是显而易见的:顺序调用、慢、一旦某个service出现异常,返回时间不可预知,可能会导致调用阻塞。

一个优化的方法就是讲将处理请求时对外部的服务调用分发到goroutine中,再汇总返回结果。并且通过设置一个总体超时时间,让调用返回的时间可预知。:

  func handleRequestByDAM() {
    c1, c2, c3 := make(chan Result1), make(chan Result2), make(chan Result3)
    go func() { c1 <- invokeService1() } ()
    go func() { c2 <- invokeService2() } ()
    go func() { c3 <- invokeService3() } ()
    timeout := time.After(200 * time.Millisecond)
    for i := 0; i < 3; i++ {
        select {
        case r := <-c1: //handle result1
            c1 = nil
        case r := <-c2: //handle result2
            c2 = nil
        case r := <-c3: //handle result3
            c3 = nil
        case <-timeout:
            fmt.Println("timed out")
            return
        }
    }
    return
  }

不过这次优化后的程序依旧存在一个问题,那就是一旦timeout,调用返回,但一些在途的请求资源可能没有回收,request无法显式撤回,久而久之,可能导致资源的泄露。于是我们做进一步改进:通过Context显式cancel掉已经向外发起的在途请求,释放占用资源:

  type service func() result
  func invokeService(ctx context.Context, s service) chan result {
    c := make(chan result)
    go func() {
      c1 := make(chan result)
      go func() {
        c1 <-s()
      }
      select {
        case v := <-c1:
             c <-v
        case <-ctx.Done():
        // cancel this in-flight request by closing its connection.
      }
    }()
    return c
  }

  func handleRequestByDAM() {
    ctx, cf := context.WithCancel(context.Background())
    c1, c2, c3 := invokeService(ctx, service1), invokeService(ctx, service2),
                   invokeService(ctx, service3)
    timeout := time.After(200 * time.Millisecond)
    for i := 0; i < 3; i++ {
        select {
        case r := <-c1: //handle result1
        case r := <-c2: //handle result2
        case r := <-c3: //handle result3
        case <-timeout:
            cf() // cancel all service invoke requests
            return
        }
    }
    return
  }

优化后的程序的优点:并发、快、返回结果可预知。

七、总结

通过这篇文章,我总结了主导Go语言编程思维的三个价值观:

  • Overall Simplicity
  • Orthogonal Composition
  • Preference in Concurrency

阐述了每种价值观主导下的编程思维,并给出了每种编程思维在语言设计、语言应用方面的一些模式和实际例子。

Go最初的设计初衷还有一点,那就是将编程时的fun重新带给Gopher们。但个人觉得只有当你使用Go编程思维去写Go code时,你才能体会到Go设计者的用意,才能让你没有别扭的赶脚,发现自己走在正确的way上,才能真正感到go coding时的fun。

另外,虽然总结出的三个价值观数量不多,但如果能在实际运用中认真践行,却能迸发巨大能量。它会让你应对各种复杂情况、代码设计变得游刃有余、顺利解决各种业务问题。

最后再说说Go 2.0。回到前面的 “编程语言思维的形成”模型,行为总是对结构有反馈的,这将导致结构的持续改变和优化。Go team将于今年8月份发布Go1.9版本,这是一个关键的时间节点。恰好今年的denver的Gophercon大会上,Russ Cox将做”the future of go”的演讲,后续是继续1.10还是Go 2.0,让我们拭目以待!不过个人觉得,无论对语言结构改动的需求有多大,Go的价值观都是不会发生改变的。

本文的slide文件可以在这里下载。


微博:@tonybai_cn
微信公众号:iamtonybai
github.com: https://github.com/bigwhite

Go 1.8中值得关注的几个变化

在已经过去的2016年Go语言继在2009年之后再次成为编程语言界的明星- 问鼎TIOBE 2016年度语言。这与Go team、Go community和全世界的Gophers的努力是分不开的。按计划在这个2月份,Go team将正式发布Go 1.8版本(截至目前,Go的最新版本是Go 1.8rc3)。在这里我们一起来看一下在Go 1.8版本中都有哪些值得Gopher们关注的变化。

一、语言(Language)

Go 1.8版本依旧坚守Go Team之前的承诺,即Go1兼容性:使用Go 1.7及以前版本编写的Go代码,理论上都可以通过Go 1.8进行编译并运行。因此在臆想中的Go 2.0变成现实之前,每个Go Release版本在语言这方面的“改变”都会是十分微小的。

1、仅tags不同的两个struct可以相互做显式类型转换

在Go 1.8版本以前,两个struct即便字段个数相同且每个字段类型均一样,但如果某个字段的tag描述不一样,这两个struct相互间也不能做显式类型转换,比如:

//go18-examples/language/structtag.go
package main

import "fmt"

type XmlEventRegRequest struct {
    AppID     string `xml:"appid"`
    NeedReply int    `xml:"Reply,omitempty"`
}

type JsonEventRegRequest struct {
    AppID     string `json:"appid"`
    NeedReply int    `json:"reply,omitempty"`
}

func convert(in *XmlEventRegRequest) *JsonEventRegRequest {
    out := &JsonEventRegRequest{}
    *out = (JsonEventRegRequest)(*in)
    return out
}

func main() {
    in := XmlEventRegRequest{
        AppID:     "wx12345678",
        NeedReply: 1,
    }
    out := convert(&in)
    fmt.Println(out)
}

采用Go 1.7.4版本go compiler进行编译,我们会得到如下错误输出:

$go build structtag.go
# command-line-arguments
./structtag.go:17: cannot convert *in (type XmlEventRegRequest) to type JsonEventRegRequest

但在Go 1.8中,gc将忽略tag值的不同,使得显式类型转换成为可能:

$go run structtag.go
&{wx12345678 1}

改变虽小,但带来的便利却不小,否则针对上面代码中的convert,我们只能做逐一字段赋值了。

2、浮点常量的指数部分至少支持16bits长

在Go 1.8版本之前的The Go Programming Language Specificaton中,关于浮点数常量的指数部分的描述如下:

Represent floating-point constants, including the parts of a complex constant, with a mantissa of at least 256 bits and a signed exponent of at least 32 bits.

在Go 1.8版本中,文档中对于浮点数常量指数部分的长度的实现的条件放宽了,由支持最少32bit,放宽到最少支持16bits:

Represent floating-point constants, including the parts of a complex constant, with a mantissa of at least 256 bits and a signed binary exponent of at least 16 bits.

但Go 1.8版本go compiler实际仍然支持至少32bits的指数部分长度,因此这个改变对现存的所有Go源码不会造成影响。

二、标准库(Standard Library)

Go号称是一门”Batteries Included”编程语言。“Batteries Included”指的就是Go语言强大的标准库。使用Go标准库,你可以完成绝大部分你想要的功能,而无需再使用第三方库。Go语言的每次版本更新,都会在标准库环节增加强大的功能、提升性能或是提高使用上的便利性。每次版本更新,标准库也是改动最大的部分。这次也不例外,我们逐一来看。

1、便于slice sort的sort.Slice函数

在Go 1.8之前我们要对一个slice进行sort,需要定义出实现了下面接口的slice type:

//$GOROOT/src/sort.go
... ...
type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element with
    // index i should sort before the element with index j.
    Less(i, j int) bool
    // Swap swaps the elements with indexes i and j.
    Swap(i, j int)
}

标准库定义了一些应对常见类型slice的sort类型以及对应的函数:

StringSlice -> sort.Strings
IntSlice -> sort.Ints
Float64Slice -> sort.Float64s

但即便如此,对于用户定义的struct或其他自定义类型的slice进行排序仍需定义一个新type,比如下面这个例子中的TiboeIndexByRank:

//go18-examples/stdlib/sort/sortslice-before-go18.go
package main

import (
    "fmt"
    "sort"
)

type Lang struct {
    Name string
    Rank int
}

type TiboeIndexByRank []Lang

func (l TiboeIndexByRank) Len() int           { return len(l) }
func (l TiboeIndexByRank) Less(i, j int) bool { return l[i].Rank < l[j].Rank }
func (l TiboeIndexByRank) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }

func main() {
    langs := []Lang{
        {"rust", 2},
        {"go", 1},
        {"swift", 3},
    }
    sort.Sort(TiboeIndexByRank(langs))
    fmt.Printf("%v\n", langs)
}

$go run sortslice-before-go18.go
[{go 1} {rust 2} {swift 3}]

从上面的例子可以看到,我们要对[]Lang这个slice进行排序,我们就需要为之定义一个专门用于排序的类型:这里是TiboeIndexByRank,并让其实现sort.Interface接口。使用过sort包的gophers们可能都意识到了,我们在为新的slice type实现sort.Interface接口时,那三个方法的Body几乎每次都是一样的。为了使得gopher们在排序slice时编码更为简化和便捷,减少copy&paste,Go 1.8为slice type新增了三个函数:Slice、SliceStable和SliceIsSorted。我们重新用Go 1.8的sort.Slice函数实现上面例子中的排序需求,代码如下:

//go18-examples/stdlib/sort/sortslice-in-go18.go
package main

import (
    "fmt"
    "sort"
)

type Lang struct {
    Name string
    Rank int
}

func main() {
    langs := []Lang{
        {"rust", 2},
        {"go", 1},
        {"swift", 3},
    }
    sort.Slice(langs, func(i, j int) bool { return langs[i].Rank < langs[j].Rank })
    fmt.Printf("%v\n", langs)
}

$go run sortslice-in-go18.go
[{go 1} {rust 2} {swift 3}]

实现sort,需要三要素:Len、Swap和Less。在1.8之前,我们通过实现sort.Interface实现了这三个要素;而在1.8版本里,Slice函数通过reflect获取到swap和length,通过结合闭包实现的less参数让Less要素也具备了。我们从下面sort.Slice的源码可以看出这一点:

// $GOROOT/src/sort/sort.go
... ...
func Slice(slice interface{}, less func(i, j int) bool) {
    rv := reflect.ValueOf(slice)
    swap := reflect.Swapper(slice)
    length := rv.Len()
    quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}

2、支持HTTP/2 Push

继在Go 1.6版本全面支持HTTP/2之后,Go 1.8又新增了对HTTP/2 Push的支持。HTTP/2是在HTTPS的基础上的下一代HTTP协议,虽然当前HTTPS的应用尚不是十分广泛。而HTTP/2 Push是HTTP/2的一个重要特性,无疑其提出的初衷也仍然是为了改善网络传输性能,提高Web服务的用户侧体验。这里我们可以借用知名网络提供商Cloudflare blog上的一幅示意图来诠释HTTP/2 Push究竟是什么:

img{512x368}

从上图中,我们可以看到:当Browser向Server发起Get page.html请求后,在同一条TCP Connection上,Server主动将style.css和image.png两个资源文件推送(Push)给了Browser。这是由于Server端启用了HTTP/2 Push机制,并预测判断Browser很可能会在接下来发起Get style.css和image.png两个资源的请求。这是一种典型的:“你可能会需要,但即使你不要,我也推给你”的处世哲学^0^。这种机制虽然在一定程度上能改善网络传输性能(减少Client发起Get的次数),但也可能造成带宽的浪费,因为这些主动推送给Browser的资源很可能是Browser所不需要的或是已经在Browser cache中存在的资源。

接下来,我们来看看Go 1.8是如何在net/http包中提供对HTTP/2 Push的支持的。由于HTTP/2是基于HTTPS的,因此我们先使用generate_cert.go生成程序所需的私钥和证书:

// 在go18-examples/stdlib/http2-push目录下,执行:

$go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1
2017/01/27 10:58:01 written cert.pem
2017/01/27 10:58:01 written key.pem

支持HTTP/2 Push的server端代码如下:

// go18-examples/stdlib/http2-push/server.go

package main

import (
    "fmt"
    "log"
    "net/http"
)

const mainJS = `document.write('Hello World!');`

func main() {
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static"))))

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/" {
            http.NotFound(w, r)
            return
        }
        pusher, ok := w.(http.Pusher)
        if ok {
            // If it's a HTTP/2 Server.
            // Push is supported. Try pushing rather than waiting for the browser.
            if err := pusher.Push("/static/img/gopherizeme.png", nil); err != nil {
                log.Printf("Failed to push: %v", err)
            }
        }
        fmt.Fprintf(w, `<html>
<head>
<title>Hello Go 1.8</title>
</head>
<body>
    <img src="/static/img/gopherizeme.png"></img>
</body>
</html>
`)
    })
    log.Fatal(http.ListenAndServeTLS(":8080", "./cert.pem", "./key.pem", nil))
}

运行这段代码,打开Google Chrome浏览器,输入:https://127.0.0.1:8080,忽略浏览器的访问非受信网站的警告,继续浏览你就能看到下面的页面(这里打开了Chrome的“检查”功能):

img{512x368}

从示例图中的“检查”窗口,我们可以看到gopherizeme.png这个image资源就是Server主动推送给客户端的,这样浏览器在Get /后无需再发起一次Get /static/img/gopherizeme.png的请求了。

而这一切的背后,其实是HTTP/2的ResponseWriter实现了Go 1.8新增的http.Pusher interface:

// $GOROOT/src/net/http/http.go

// Pusher is the interface implemented by ResponseWriters that support
// HTTP/2 server push. For more background, see
// https://tools.ietf.org/html/rfc7540#section-8.2.
type Pusher interface {
    ... ...
    Push(target string, opts *PushOptions) error
}

3、支持HTTP Server优雅退出

Go 1.8中增加对HTTP Server优雅退出(gracefullly exit)的支持,对应的新增方法为:

func (srv *Server) Shutdown(ctx context.Context) error

和server.Close在调用时瞬间关闭所有active的Listeners和所有状态为New、Active或idle的connections不同,server.Shutdown首先关闭所有active Listeners和所有处于idle状态的Connections,然后无限等待那些处于active状态的connection变为idle状态后,关闭它们并server退出。如果有一个connection依然处于active状态,那么server将一直block在那里。因此Shutdown接受一个context参数,调用者可以通过context传入一个Shutdown等待的超时时间。一旦超时,Shutdown将直接返回。对于仍然处理active状态的Connection,就任其自生自灭(通常是进程退出后,自动关闭)。通过Shutdown的源码我们也可以看出大致的原理:

// $GOROOT/src/net/http/server.go
... ...
func (srv *Server) Shutdown(ctx context.Context) error {
    atomic.AddInt32(&srv.inShutdown, 1)
    defer atomic.AddInt32(&srv.inShutdown, -1)

    srv.mu.Lock()
    lnerr := srv.closeListenersLocked()
    srv.closeDoneChanLocked()
    srv.mu.Unlock()

    ticker := time.NewTicker(shutdownPollInterval)
    defer ticker.Stop()
    for {
        if srv.closeIdleConns() {
            return lnerr
        }
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-ticker.C:
        }
    }
}

我们来编写一个例子:

// go18-examples/stdlib/graceful/server.go

import (
    "context"
    "io"
    "log"
    "net/http"
    "os"
    "os/signal"
    "time"
)

func main() {
    exit := make(chan os.Signal)
    signal.Notify(exit, os.Interrupt)

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Println("Handle a new request:", *r)
        time.Sleep(10 * time.Second)
        log.Println("Handle the request ok!")
        io.WriteString(w, "Finished!")
    })

    srv := &http.Server{
        Addr:    ":8080",
        Handler: http.DefaultServeMux,
    }

    go func() {
        if err := srv.ListenAndServe(); err != nil {
            log.Printf("listen: %s\n", err)
        }
    }()

    <-exit // wait for SIGINT
    log.Println("Shutting down server...")

    // Wait no longer than 30 seconds before halting
    ctx, _ := context.WithTimeout(context.Background(), 30*time.Second)
    err := srv.Shutdown(ctx)

    log.Println("Server gracefully stopped:", err)
}

在上述例子中,我们通过设置Linux Signal的处理函数来拦截Linux Interrupt信号并处理。我们通过context给Shutdown传入30s的超时参数,这样Shutdown在退出之前会给各个Active connections 30s的退出时间。下面分为几种情况run一下这个例子:

a) 当前无active connections

在这种情况下,我们run上述demo,ctrl + C后,上述demo直接退出:

$go run server.go
^C2017/02/02 15:13:16 Shutting down server...
2017/02/02 15:13:16 Server gracefully stopped: <nil>

b) 当前有未处理完的active connections,ctx 超时

为了模拟这一情况,我们修改一下参数。让每个request handler的sleep时间为30s,而Shutdown ctx的超时时间改为10s。我们再来运行这个demo,并通过curl命令连接该server(curl -v http://localhost:8080),待连接成功后,再立即ctrl+c停止Server,待约10s后,我们得到如下日志:

$go run server.go
2017/02/02 15:15:57 Handle a new request: {GET / HTTP/1.1 1 1 map[User-Agent:[curl/7.30.0] Accept:[*/*]] {} <nil> 0 [] false localhost:8080 map[] map[] <nil> map[] [::1]:52590 / <nil> <nil> <nil> 0xc420016700}
^C2017/02/02 15:15:59 Shutting down server...
2017/02/02 15:15:59 listen: http: Server closed
2017/02/02 15:16:09 Server gracefully stopped: context deadline exceeded

c) 当前有未处理完的active connections,ctx超时之前,这些connections处理ok了

我们将上述demo的参数还原,即request handler sleep 10s,而Shutdown ctx超时时间为30s,运行这个Demo后,通过curl命令连接该server,待连接成功后,再立即ctrl+c停止Server。等待约10s后,我们得到如下日志:

$go run server.go
2017/02/02 15:19:56 Handle a new request: {GET / HTTP/1.1 1 1 map[User-Agent:[curl/7.30.0] Accept:[*/*]] {} <nil> 0 [] false localhost:8080 map[] map[] <nil> map[] [::1]:52605 / <nil> <nil> <nil> 0xc420078500}
^C2017/02/02 15:19:59 Shutting down server...
2017/02/02 15:19:59 listen: http: Server closed
2017/02/02 15:20:06 Handle the request ok!
2017/02/02 15:20:06 Server gracefully stopped: <nil>

可以看出,当ctx超时之前,request处理ok,connection关闭。这时不再有active connection和idle connection了,Shutdown成功返回,server立即退出。

4、Mutex Contention Profiling

Go 1.8中runtime新增了对Mutex和RWMutex的profiling(剖析)支持。golang team成员,负责从go user角度去看待go team的work是否满足用户需求的Jaana B. Dogan在其个人站点上写了一篇介绍mutex profiling的文章,这里借用一下其中的Demo:

//go18-examples/stdlib/mutexprofile/mutexprofile.go

package main

import (
    "net/http"
    _ "net/http/pprof"
    "runtime"
    "sync"
)

func main() {
    var mu sync.Mutex
    var items = make(map[int]struct{})

    runtime.SetMutexProfileFraction(5)
    for i := 0; i < 1000*1000; i++ {
        go func(i int) {
            mu.Lock()
            defer mu.Unlock()
            items[i] = struct{}{}
        }(i)
    }

    http.ListenAndServe(":8888", nil)
}

运行该程序后,在浏览器中输入:http://localhost:8888/debug/pprof/mutex,你就可以看到有关该程序的mutex profile(耐心等待一小会儿,因为数据的采样需要一点点时间^0^):

--- mutex:
cycles/second=2000012082
sampling period=5
378803564 776 @ 0x106c4d1 0x13112ab 0x1059991

构建该程序,然后通过下面命令:

go build mutexprofile.go
./mutexprofile
go tool pprof mutexprofile http://localhost:8888/debug/pprof/mutex?debug=1

可以进入pprof交互界面,这个是所有用过go pprof工具gophers们所熟知的:

$go tool pprof mutexprofile http://localhost:8888/debug/pprof/mutex?debug=1
Fetching profile from http://localhost:8888/debug/pprof/mutex?debug=1
Saved profile in /Users/tony/pprof/pprof.mutexprofile.localhost:8888.contentions.delay.003.pb.gz
Entering interactive mode (type "help" for commands)
(pprof) list
Total: 12.98s
ROUTINE ======================== main.main.func1 in /Users/tony/Test/GoToolsProjects/src/github.com/bigwhite/experiments/go18-examples/stdlib/mutexprofile/mutexprofile.go
         0     12.98s (flat, cum)   100% of Total
         .          .     17:            mu.Lock()
         .          .     18:            defer mu.Unlock()
         .          .     19:            items[i] = struct{}{}
         .          .     20:        }(i)
         .          .     21:    }
         .     12.98s     22:
         .          .     23:    http.ListenAndServe(":8888", nil)
         .          .     24:}
ROUTINE ======================== runtime.goexit in /Users/tony/.bin/go18rc2/src/runtime/asm_amd64.s
         0     12.98s (flat, cum)   100% of Total
         .          .   2192:    RET
         .          .   2193:
         .          .   2194:// The top-most function running on a goroutine
         .          .   2195:// returns to goexit+PCQuantum.
         .          .   2196:TEXT runtime·goexit(SB),NOSPLIT,$0-0
         .     12.98s   2197:    BYTE    $0x90    // NOP
         .          .   2198:    CALL    runtime·goexit1(SB)    // does not return
         .          .   2199:    // traceback from goexit1 must hit code range of goexit
         .          .   2200:    BYTE    $0x90    // NOP
         .          .   2201:
         .          .   2202:TEXT runtime·prefetcht0(SB),NOSPLIT,$0-8
ROUTINE ======================== sync.(*Mutex).Unlock in /Users/tony/.bin/go18rc2/src/sync/mutex.go
    12.98s     12.98s (flat, cum)   100% of Total
         .          .    121:            return
         .          .    122:        }
         .          .    123:        // Grab the right to wake someone.
         .          .    124:        new = (old - 1<<mutexWaiterShift) | mutexWoken
         .          .    125:        if atomic.CompareAndSwapInt32(&m.state, old, new) {
    12.98s     12.98s    126:            runtime_Semrelease(&m.sema)
         .          .    127:            return
         .          .    128:        }
         .          .    129:        old = m.state
         .          .    130:    }
         .          .    131:}
(pprof) top10
1.29s of 1.29s total (  100%)
      flat  flat%   sum%        cum   cum%
     1.29s   100%   100%      1.29s   100%  sync.(*Mutex).Unlock
         0     0%   100%      1.29s   100%  main.main.func1
         0     0%   100%      1.29s   100%  runtime.goexit

go pprof的另外一个用法就是在go test时,mutexprofile同样支持这一点:

go test -mutexprofile=mutex.out
go tool pprof <test.binary> mutex.out

5、其他重要改动

Go 1.8标准库还有两个值得注意的改动,一个是:crypto/tls,另一个是database/sql。

HTTPS逐渐成为主流的今天,各个编程语言对HTTPS连接的底层加密协议- TLS协议支持的成熟度日益被人们所关注。Go 1.8给广大Gophers们带来了一个更为成熟、性能更好、更为安全的TLS实现,同时也增加了对一些TLS领域最新协议规范的支持。无论你是实现TLS Server端,还是Client端,都将从中获益。

Go 1.8在crypto/tls中提供了基于ChaCha20-Poly1305的cipher suite,其中ChaCha20是一种stream cipher算法;而Poly1305则是一种code authenticator算法。它们共同组成一个TLS suite。使用这个suite,将使得你的web service或站点具有更好的mobile浏览性能,这是因为传统的AES算法实现在没有硬件支持的情况下cost更多。因此,如果你在使用tls时没有指定cipher suite,那么Go 1.8会根据硬件支持情况(是否有AES的硬件支持),来决定是使用ChaCha20还是AES算法。除此之外,crypto/tls还实现了更为安全和高效的X25519密钥交换算法等。

Go 1.4以来,database/sql包的变化很小,但对于该包的feature需求却在与日俱增。终于在Go 1.8这个dev cycle中,govendor的作者Daniel TheophanesBrad Fitzpatrick的“指导”下,开始对database/sql进行“大规模”的改善。在Go 1.8中,借助于context.Context的帮助,database/sql增加了Cancelable Queries、SQL Database Type、Multiple Result Sets、Database ping、Named Parameters和Transaction Isolation等新Features。在GopherAcademy的Advent 2016系列文章中,我们可以看到Daniel Theophanes亲手撰写的文章,文章针对Go 1.8 database/sql包新增的features作了详细解释。

三、Go工具链(Go Toolchain)

在目前市面上的主流编程语言中,如果说Go的工具链在成熟度和完善度方面排第二,那没有语言敢称自己是第一吧^_^。Go 1.8在Go Toolchain上继续做着持续地改进,下面我们来逐一看看。

1、Plugins

Go在1.8版本中提供了对Plugin的初步支持,并且这种支持仅限于Linux。plugin这个术语在不同语言、不同情景上下文中有着不同的含义,那么什么是Go Plugin呢?

Go Plugin为Go程序提供了一种在运行时加载代码、执行代码以改变运行行为的能力,它实质上由两个部分组成:

  • go build -buildmode=plugin xx.go 构建xx.so plugin文件
  • 利用plugin包在运行时动态加载xx.so并执行xx.so中的代码

C程序员看到这里肯定会有似曾相识的赶脚,因为这和传统的动态共享库在概念上十分类似:

go build -buildmode=plugin xx.go 类似于 gcc -o xx.so -shared xx.c
go plugin包 类似于 linux上的dlopen/dlsym或windows上的LoadLibrary

我们来看一个例子!我们先来建立一个名为foo.so的go plugin:

//go18-examples/gotoolchain/plugins/foo.go

package main

import "fmt"

var V int
var v int

func init() {
        V = 17
        v = 23
        fmt.Println("init function in plugin foo")
}

func Foo(in string) string {
        return "Hello, " + in
}

func foo(in string) string {
        return "hello, " + in
}

通过go build命令将foo.go编译为foo.so:

# go build -buildmode=plugin foo.go
# ldd foo.so
    linux-vdso.so.1 =>  (0x00007ffe47f67000)
    libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f9d06f4b000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f9d06b82000)
    /lib64/ld-linux-x86-64.so.2 (0x000055c69cfcf000)

# nm foo.so|grep Foo
0000000000150010 t local.plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879.Foo
0000000000150010 T plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879.Foo
000000000036a0dc D type..namedata.Foo.

我们看到go plugin的.so文件就是一个标准的Linux动态共享库文件,我们可以通过nm命令查看.so中定义的各种符号。接下来,我们来load这个.so,并查找并调用相应符号:

//go18-examples/gotoolchain/plugins/main.go

package main

import (
        "fmt"
        "plugin"
        "time"
)

func init() {
        fmt.Println("init in main program")
}

func loadPlugin(i int) {
        fmt.Println("load plugin #", i)
        var err error
        fmt.Println("before opening the foo.so")

        p, err := plugin.Open("foo.so")
        if err != nil {
                fmt.Println("plugin Open error:", err)
                return
        }
        fmt.Println("after opening the foo.so")

        f, err := p.Lookup("Foo")
        if err != nil {
                fmt.Println("plugin Lookup symbol Foo error:", err)
        } else {
                fmt.Println(f.(func(string) string)("gophers"))
        }

        f, err = p.Lookup("foo")
        if err != nil {
                fmt.Println("plugin Lookup symbol foo error:", err)
        } else {
                fmt.Println(f.(func(string) string)("gophers"))
        }

        v, err := p.Lookup("V")
        if err != nil {
                fmt.Println("plugin Lookup symbol V error:", err)
        } else {
                fmt.Println(*v.(*int))
        }

        v, err = p.Lookup("v")
        if err != nil {
                fmt.Println("plugin Lookup symbol v error:", err)
        } else {
                fmt.Println(*v.(*int))
        }
        fmt.Println("load plugin #", i, "done")
}

func main() {
        var counter int = 1
        for {
                loadPlugin(counter)
                counter++
                time.Sleep(time.Second * 30)
        }
}

执行这个程序:

# go run main.go
init in main program
load plugin # 1
before opening the foo.so
init function in plugin foo
after opening the foo.so
Hello, gophers
plugin Lookup symbol foo error: plugin: symbol foo not found in plugin plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879
17
plugin Lookup symbol v error: plugin: symbol v not found in plugin plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879
load plugin # 1 done

load plugin # 2
before opening the foo.so
after opening the foo.so
Hello, gophers
plugin Lookup symbol foo error: plugin: symbol foo not found in plugin plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879
17
plugin Lookup symbol v error: plugin: symbol v not found in plugin plugin/unnamed-69e21ef38d16a3fee5eb7b9e515c27a389067879
load plugin # 2 done
... ...

我们来分析一下这个执行结果!

a) foo.go中的代码也包含在main package下,但只是当foo.so被第一次加载时,foo.go中的init函数才会被执行;
b) foo.go中的exported function和variable才能被Lookup到,如Foo、V;查找unexported的变量和函数符号将得到error信息,如:“symbol foo not found in plugin”;
c) Lookup返回的是plugin.Symbol类型的值,plugin.Symbol是一个指向plugin中变量或函数的指针;
d) foo.go中的init在后续重复加载中并不会被执行。

注意:plugin.Lookup是goroutine-safe的。

在golang-dev group上,有人曾问过:buildmode=c-shared和buildmode=plugin有何差别?Go team member给出的答案如下:

The difference is mainly on the program that loads the shared library.

For c-shared, we can't assume anything about the host, so the c-shared dynamic library must be self-contained, but for plugin, we know the host program will be a Go program built with the same runtime version, so the toolchain can omit at least the runtime package from the dynamic library, and possibly more if it's certain that some packages are linked into the host program. (This optimization hasn't be implemented yet, but we need the distinction to enable this kind of optimization in the future.)

2、默认的GOPATH

Go team在Go 1.8以及后续版本会更加注重”Go语言的亲民性”,即进一步降低Go的入门使用门槛,让大家更加Happy的使用Go。对于一个Go初学者来说,一上来就进行GOPATH的设置很可能让其感到有些迷惑,甚至有挫折感,就像建立Java开发环境需要设置JAVA_HOME和CLASSPATH一样。Gophers们期望能做到Go的安装即可用。因此Go 1.8就在这方面做出了改进:支持默认的GOPATH。

在Linux/Mac系下,默认的GOPATH为$HOME/go,在Windows下,GOPATH默认路径为:%USERPROFILE%/go。你可以通过下面命令查看到这一结果:

$ go env
GOARCH="amd64"
GOBIN="/home/tonybai/.bin/go18rc3/bin"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/tonybai/go"
GORACE=""
GOROOT="/home/tonybai/.bin/go18rc3"
GOTOOLDIR="/home/tonybai/.bin/go18rc3/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build313929093=/tmp/go-build -gno-record-gcc-switches"
CXX="g++"
CGO_ENABLED="1"
PKG_CONFIG="pkg-config"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"

BTW,在Linux/Mac下,默认的GOROOT为/usr/local/go,如果你的Go环境没有安装到这个路径下,在没有设置$GOROOT环境变量的情况下,当你执行go subcommand相关命令时,你会看到如下错误:

$go env
go: cannot find GOROOT directory: /usr/local/go

3、其他变化

Go 1.8删除了Go 1.7中增加的用于关闭ssa新后端的”-ssa=0” compiler flag,并且将ssa backend扩展到所有architecture中,对ssa后端也进一步做了优化。与此同时,为了将来进一步的性能优化打基础,Go 1.8还引入了一个新编译器前端,当然这对于普通Gopher的Go使用并没有什么影响。

Go 1.8还新增go bug子命令,该命令会自动使用默认浏览器打开new issue页面,并将采集到的issue提交者的系统信息填入issue模板,以帮助gopher提交符合要求的go issue,下面是go bug打开的issue page的图示:

img{512x368}

四、性能变化(Performance Improvement)

无论是Gotoolchain、还是runtime(包括GC)的性能,一直都是Go team重点关注的领域。本次Go 1.8依旧给广大Gophers们带来了性能提升方面的惊喜。

首先,Go SSA后端扩展到所有architecture和新编译器前端的引入,将会给除X86-64之外架构上运行的Go代码带来约20-30%的运行性能提升。对于x86-64,虽然Go 1.7就已经开启了SSA,但Go 1.8对SSA做了进一步优化,x86-64上的Go代码依旧可能会得到10%以内的性能提升。

其次,Go 1.8持续对Go compiler和linker做性能优化,和1.7相比,平均编译链接的性能提升幅度在15%左右。虽然依旧没有达到Go 1.4的性能水准。不过,优化依旧在持续进行中,目标的达成是可期的。

再次,GC在低延迟方面的优化给了我们最大的惊喜。在Go 1.8中,由于消除了GC的“stop-the-world stack re-scanning”,使得GC STW(stop-the-world)的时间通常低于100微秒,甚至经常低于10微秒。当然这或多或少是以牺牲“吞吐”作为代价的。因此在Go 1.9中,GC的改进将持续进行,会在吞吐和低延迟上做一个很好的平衡。

最后,defer的性能消耗在Go 1.8中下降了一半,与此下降幅度相同的还有通过cgo在go中调用C代码的性能消耗。

五、小结兼参考资料

Go 1.8的变化不仅仅是以上这些,更多变化以及详细的描述请参考下面参考资料中的“Go 1.8 Release Notes”:

以上demo中的代码在这里可以找到。




这里是Tony Bai的个人Blog,欢迎访问、订阅和留言!订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您喜欢通过微信App浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:



本站Powered by Digital Ocean VPS。

选择Digital Ocean VPS主机,即可获得10美元现金充值,可免费使用两个月哟!

著名主机提供商Linode 10$优惠码:linode10,在这里注册即可免费获得。

阿里云推荐码:1WFZ0V立享9折!

View Tony Bai's profile on LinkedIn


文章

评论

  • 正在加载...

分类

标签

归档











更多