Golang 内存模型(一)

开始之前

首先,这是一篇菜B写的文章,可能会有理解错误的地方,发现错误请斧正,谢谢。

为了治疗我的懒癌早期,我一次就不写得太多了,这个系列想写很久了,每次都是开了个头就没有再写。这次争取把写完,弄成一个系列。

此 nil 不等彼 nil

先声明,这个标题有标题党的嫌疑。

Go 的类型系统是比较奇葩的,nil 的含义跟其它语言有些差别,这里举个例子(可以直接进入 http://play.golang.org/p/ezFhXX0dnB 运行查看结果):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

type A struct {
}

func main() {
var a *A = nil
var ai interface{} = a
var ei interface{} = nil

fmt.Printf("ai == nil: %v\n", ai == nil)
fmt.Printf("ai == ei: %v\n", ai == ei)
fmt.Printf("ei == a: %v\n", a == ei)
fmt.Printf("ei == nil: %v\n", ei == nil)
}

// -> 输出
// ai == nil: false
// ai == ei: false
// ei == a: false
// ei == nil: true

这里 ai != nil,对于没有用过 Go 的人来说比较费解,对我来说,这个算得上一门语言设计有歧义的地方(Golang FAQ 有对于此问题的描述,可以参考一下:http://golang.org/doc/faq#nil_error)。

简单的说就是 nil 代表 “zero value”(空值),对于不同类型,它具体所代表的值不同。比如上面的 a 为“*A 类型的空值”,而 ai 为“interface{} 类型的空值”。造成理解失误的最大问题在于,struct pointerinterface 有隐式转换(var ai interface{] = a,这里有个隐式转换),至于为什么对于 Go 这种在其它转换方面要求严格,而对于 interface 要除外呢,for convenience 吧,呵呵……

碰到了这个坑,我就开始好奇了,Go 的类型系统到底是什么样的?

Read More

在 Go 中获取 stacktrace

打印 stacktrace
1
2
3
4
5
6
buf := make([]byte, 1<<16)
// 获取 **所有** goroutine 的 stacktrace
runtime.Stack(buf, true)
// 如果需要获取 **当前** goroutine 的 stacktrace, 第二个参数需要为 `false`
runtime.Stack(buf, true)
fmt.Println(string(buf))

太诡异了,居然要指定 buffer 的大小,用起来不方便。虽然可以给个“足够大” buffer 用来容纳 stacktrace,但是什么是“足够大”?

为了确认 runtime.Stack() 函数的 behavior,需要参考一下 Go 输出 stacktrace 的实现代码。该代码是使用 GOC 写成的。

A .goc file is a combination of a limited form of Go with C.

mprof.goclink
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
func Stack(b Slice, all bool) (n int) {
uintptr pc, sp;

// Stack pointer
sp = runtime·getcallersp(&b);
// Programer pointer
pc = (uintptr)runtime·getcallerpc(&b);

// 如果选择输出所有 goroutine 的 traceback, 挂起所有goroutine,
// 在本函数完成后恢复
if(all) {
runtime·semacquire(&runtime·worldsema, false);
m->gcing = 1;
runtime·stoptheworld();
}

if(b.len == 0)
n = 0;
else{
// 重定向输出缓冲, 打印到 `b` 这个buffer里
g->writebuf = (byte*)b.array;
// buffer具有固定大小, 因此会截断
g->writenbuf = b.len;
// proc.c: runtime·goroutineheader
runtime·goroutineheader(g);
// traceback_${arch}.c
runtime·traceback(pc, sp, 0, g);
if(all)
runtime·tracebackothers(g);
n = b.len - g->writenbuf;
g->writebuf = nil;
g->writenbuf = 0;
}

if(all) {
m->gcing = 0;
runtime·semrelease(&runtime·worldsema);
runtime·starttheworld();
}
}

因为打印到buffer会截断过长的结果,因此可以写一个包装函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func StackTrace(all bool) string {
// Reserve 10K buffer at first
buf := make([]byte, 10240)

for {
size := runtime.Stack(buf, all)
// The size of the buffer may be not enough to hold the stacktrace,
// so double the buffer size
if size == len(buf) {
buf = make([]byte, len(buf)<<1)
continue
}
break
}

return string(buf)
}

例子可以在这里看到:Go Playground