├── README.md ├── images └── book.png └── 示例代码 ├── 第2章 指针 ├── code_2_1.go ├── code_2_2.go ├── code_2_3.go ├── code_2_4.go ├── code_2_5.go ├── code_2_6.go ├── code_2_7.go └── code_2_8.go ├── 第3章 函数 ├── code_3_1.go ├── code_3_10.go ├── code_3_11.go ├── code_3_12.go ├── code_3_13.go ├── code_3_14.go ├── code_3_15.go ├── code_3_16.go ├── code_3_17.c ├── code_3_18.go ├── code_3_19.go ├── code_3_2.go ├── code_3_20.go ├── code_3_21.go ├── code_3_22.go ├── code_3_23.go ├── code_3_24.go ├── code_3_25.go ├── code_3_26.go ├── code_3_27.go ├── code_3_28.go ├── code_3_29.go ├── code_3_3.go ├── code_3_30.go ├── code_3_31.go ├── code_3_32.go ├── code_3_33.go ├── code_3_34.go ├── code_3_35.go ├── code_3_4.go ├── code_3_5.go ├── code_3_6.go ├── code_3_7.go ├── code_3_8.go └── code_3_9.go ├── 第4章 方法 ├── code_4_1.go ├── code_4_2.go ├── code_4_3.go ├── code_4_4.go ├── code_4_5.go └── code_4_6.go ├── 第5章 接口 ├── code_5_1.go ├── code_5_10.go ├── code_5_11.go ├── code_5_12.go ├── code_5_13.go ├── code_5_14.go ├── code_5_15.go ├── code_5_16.go ├── code_5_17.go ├── code_5_18.go ├── code_5_2.go ├── code_5_3.go ├── code_5_4.go ├── code_5_5.go ├── code_5_6.go ├── code_5_7.cpp ├── code_5_8.cpp ├── code_5_9.go ├── mod1 │ ├── go.mod │ └── user.go ├── mod2 │ ├── factory.go │ └── go.mod ├── mod3 │ ├── checker.go │ └── go.mod └── mod4 │ ├── go.mod │ └── main.go ├── 第6章 goroutine ├── code_6_1.go ├── code_6_2.go ├── code_6_3.go └── code_6_4.go ├── 第7章 同步 ├── code_7_1.go ├── code_7_2.go ├── code_7_3.go ├── code_7_4.go ├── code_7_5.go ├── code_7_6.go ├── code_7_7.go ├── code_7_8.go ├── fence.go ├── fence_amd64.s ├── lock_amd64.s ├── pause_amd64.s └── spin_amd64.s ├── 第8章 堆 ├── code_8_1.go ├── code_8_2.go ├── code_8_3.go ├── code_8_4.go ├── code_8_5.go └── code_8_6.go └── 第9章 栈 ├── code_9_1.go └── code_9_2.go /README.md: -------------------------------------------------------------------------------- 1 | # 《深度探索Go语言》 2 | 3 | 本书主要讲解了Go语言一些关键特性的实现原理，Nicklaus Wirth大师曾经说过：算法+数据结构=程序，语言特性的实现也不外乎就是数据结构+代码逻辑。 4 | 5 | 全书共分为四个部分：第一部分是基础特性（第1、2、3章），第二部分是对象模型（第4、5章），第三部分是调度系统（第6、7章），第四部分是内存管理（第8、9章）。书中主要内容包括：指针、函数栈帧、调用约定、变量逃逸、Function Value、闭包、defer、panic、方法、Method Value、组合式继承、接口、类型断言、反射、goroutine、抢占式调度、同步、堆和栈的管理，以及GC等。 6 | 7 | 书中包含大量的探索示例和源码分析，在学会应用的同时还能了解实现原理。书中绝大部分代码都是用Go语言实现，还有少部分使用汇编语言，都可以使用Go官方SDK直接编译。探索过程循序渐进条理清晰，用到的工具也都是SDK自带，方便读者亲自上手实践。 8 | 9 | 本书适合Go语言的初学者，在学习语言特性的同时了解其实现原理。更适合有一定的Go语言应用基础，想要深入研究底层原理的技术人员。同样适合有一些其他编程语言基础，想要转学Go语言的开发者。 10 | 11 | ![封面](images/book.png) 12 | 13 | 本书在[京东](https://item.jd.com/13391373.html)、[天猫](https://detail.tmall.com/item.htm?id=683938577791)和[当当](http://product.dangdang.com/29462109.html)等各大电商平台有售。读者如果有任何疑问，欢迎微信搜索KylinLabs添加作者好友，加入幼麟实验室交流群。 -------------------------------------------------------------------------------- /images/book.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kylinlabs/gobook/a9cdb8ba9c1d73a6cb3c17f1413a66d35ca8767c/images/book.png -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_1.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_1.go 2 | package main 3 | 4 | func main() { 5 | n := 10 6 | println(read(&n)) 7 | } 8 | 9 | //go:noinline 10 | func read(p *int) (v int) { 11 | v = *p 12 | return 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_2.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_2.go 2 | //go:noinline 3 | func read32(p *int32) (v int32) { 4 | v = *p 5 | return 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_3.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_3.go 2 | package main 3 | 4 | var n int 5 | 6 | func main() { 7 | println(addr()) 8 | } 9 | 10 | //go:noinline 11 | func addr() (p *int) { 12 | return &n 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_4.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_4.go 2 | //go:noinline 3 | func newInt() (p *int) { 4 | var n int 5 | return &n 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_5.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_5.go 2 | //go:noinline 3 | func convert(p *int) { 4 | q := (*int32)(unsafe.Pointer(p)) 5 | *q = 0 6 | } 7 | 8 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_6.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_6.go 2 | //go:noinline 3 | func size() (o uintptr) { 4 | o = unsafe.Sizeof(o) 5 | return 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_7.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_7.go 2 | type s1 struct { 3 | a int8 4 | b int64 5 | c int8 6 | d int32 7 | e int16 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第2章 指针/code_2_8.go: -------------------------------------------------------------------------------- 1 | //第2章/code_2_8.go 2 | type s2 struct { 3 | a int8 4 | c int8 5 | e int16 6 | d int32 7 | b int64 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_1.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_1.go 2 | package main 3 | 4 | func main() { 5 | var v1, v2 int 6 | v3, v4 := f1(v1, v2) 7 | println(&v1, &v2, &v3, &v4) 8 | f2(v3) 9 | } 10 | 11 | //go:noinline 12 | func f1(a1, a2 int) (r1, r2 int) { 13 | var l1, l2 int 14 | println(&r2, &r1, &a2, &a1, &l1, &l2) 15 | return 16 | } 17 | 18 | //go:noinline 19 | func f2(a1 int) { 20 | println(&a1) 21 | } 22 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_10.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_10.go 2 | package main 3 | 4 | func main() { 5 | println(*newInt()) 6 | } 7 | 8 | //go:noinline 9 | func newInt() *int { 10 | var a int 11 | return &a 12 | } 13 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_11.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_11.go 2 | //go:noinline 3 | func New() int { 4 | p := new(int) 5 | return *p 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_12.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_12.go 2 | var pt *int 3 | 4 | //go:noinline 5 | func setNew() { 6 | var a int 7 | pt = &a 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_13.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_13.go 2 | var pp **int 3 | 4 | //go:noinline 5 | func dep() { 6 | var a int 7 | var p *int 8 | p = &a 9 | pp = &p 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_14.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_14.go 2 | package inner 3 | 4 | //go:noinline 5 | func RetArg(p *int) *int { 6 | return p 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_15.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_15.go 2 | package main 3 | 4 | //go:noinline 5 | func arg() int { 6 | var a int 7 | return *inner.RetArg(&a) 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_16.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_16.go 2 | //go:linkname retArg funny/inner.RetArg 3 | func retArg(p *int) *int 4 | 5 | //go:noinline 6 | func arg() int { 7 | var a int 8 | var b int 9 | return *inner.RetArg(&a) + *retArg(&b) 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_17.c: -------------------------------------------------------------------------------- 1 | //第3章/code_3_17.c 2 | int helper(int (*fn)(int, int), int a, int b) { 3 | return fn(a, b); 4 | } 5 | 6 | int main() { 7 | return helper(0, 0, 0); 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_18.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_18.go 2 | package main 3 | 4 | func main() { 5 | println(helper(nil, 0, 0)) 6 | } 7 | 8 | //go:noinline 9 | func helper(fn func(int, int) int, a, b int) int { 10 | return fn(a, b) 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_19.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_19.go 2 | func mc(n int) func() int { 3 | return func() int { 4 | return n 5 | } 6 | } -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_2.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_2.go 2 | var a, b int 3 | println(&a, &b) -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_20.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_20.go 2 | func mc2(a, b int) func() (int, int) { 3 | return func() (int, int) { 4 | return a, b 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_21.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_21.go 2 | package main 3 | 4 | import ( 5 | "reflect" 6 | "unsafe" 7 | 8 | "github.com/fengyoulin/hookingo" 9 | ) 10 | 11 | var hno hookingo.Hook 12 | 13 | //go:linkname newobject runtime.newobject 14 | func newobject(typ unsafe.Pointer) unsafe.Pointer 15 | 16 | func fno(typ unsafe.Pointer) unsafe.Pointer { 17 | t := reflect.TypeOf(0) 18 | (*(*[2]unsafe.Pointer)(unsafe.Pointer(&t)))[1] = typ // 相当于反射了闭包对象类型 19 | println(t.String()) 20 | if fn, ok := hno.Origin().(func(typ unsafe.Pointer) unsafe.Pointer); ok { 21 | return fn(typ) // 调用原runtime.newobject 22 | } 23 | return nil 24 | } 25 | 26 | // 创建一个闭包，make closure 27 | func mc(start int) func() int { 28 | return func() int { 29 | start++ 30 | return start 31 | } 32 | } 33 | 34 | func main() { 35 | var err error 36 | hno, err = hookingo.Apply(newobject, fno) // 应用钩子，替换函数 37 | if err != nil { 38 | panic(err) 39 | } 40 | f := mc(10) 41 | println(f()) 42 | } 43 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_22.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_22.go 2 | func mc(n int) func() int { 3 | return func() int { 4 | return n 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_23.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_23.go 2 | func sc(n int) int { 3 | f := func() int { 4 | return n 5 | } 6 | return f() 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_24.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_24.go 2 | func sc(n int) int { 3 | f := func() int { 4 | n++ 5 | return n 6 | } 7 | return f() 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_25.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_25.go 2 | func sc(n int) int { 3 | n++ 4 | f := func() int { 5 | return n 6 | } 7 | return f() 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_26.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_26.go 2 | func sc(n int) int { 3 | f := func() int { 4 | return n 5 | } 6 | n++ 7 | return f() 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_27.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_27.go 2 | func fn() func() { 3 | return func() { 4 | println("defer") 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_28.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_28.go 2 | package main 3 | 4 | func main() { 5 | println(df(10)) 6 | } 7 | 8 | func df(n int) int { 9 | defer func(i *int) { 10 | *i *= 2 11 | }(&n) 12 | return n 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_29.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_29.go 2 | func fn(n int) (r int) { 3 | if n&1 != 0 { 4 | defer func() { 5 | r <<= 1 6 | }() 7 | } 8 | for i := 0; i < n; i++ { 9 | defer func() { 10 | r <<= 1 11 | }() 12 | } 13 | return n 14 | } 15 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_3.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_3.go 2 | package main 3 | 4 | func main() { 5 | fa(0) 6 | } 7 | 8 | //go:noinline 9 | func fa(n int) (r int) { 10 | r = fb(n) 11 | return 12 | } 13 | 14 | //go:noinline 15 | func fb(n int) int { 16 | return n 17 | } 18 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_30.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_30.go 2 | func fn(n int) (r int) { 3 | if n > 0 { 4 | defer func(i int) { 5 | r <<= i 6 | }(n) 7 | } 8 | n++ 9 | return n 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_31.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_31.go 2 | func fn() { 3 | defer func(a int) { 4 | recover() 5 | println(a) 6 | }(0) 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_32.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_32.go 2 | func fn() { 3 | defer func() { 4 | recover() 5 | }() 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_33.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_33.go 2 | func fn() { 3 | defer func() { 4 | r() 5 | }() 6 | } 7 | 8 | func r() { 9 | recover() 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_34.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_34.go 2 | func fn() { 3 | defer func() { 4 | panic("2") 5 | }() 6 | panic("1") 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_35.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_35.go 2 | func fn() { 3 | defer func() { 4 | defer func() { 5 | recover() 6 | } 7 | panic("2") 8 | }() 9 | panic("1") 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_4.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_4.go 2 | package main 3 | 4 | type args struct { 5 | a int8 6 | b int64 7 | c int32 8 | d int16 9 | } 10 | 11 | //go:noinline 12 | func f1(a args) (r args) { 13 | println(&r.d, &r.c, &r.b, &r.a, &a.d, &a.c, &a.b, &a.a) 14 | return 15 | } 16 | 17 | //go:noinline 18 | func f2(aa int8, ab int64, ac int32, ad int16) (ra int8, rb int64, rc int32, rd int16) { 19 | println(&rd, &rc, &rb, &ra, &ad, &ac, &ab, &aa) 20 | return 21 | } 22 | 23 | func main() { 24 | f1(args{}) 25 | f2(0, 0, 0, 0) 26 | } 27 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_5.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_5.go 2 | package main 3 | 4 | //go:noinline 5 | func f1(a int8) (b int8) { 6 | println(&b, &a) 7 | return 8 | } 9 | 10 | func main() { 11 | f1(0) 12 | } 13 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_6.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_6.go 2 | //go:noinline 3 | func fn() { 4 | var a int8 5 | var b int64 6 | var c int32 7 | var d int16 8 | var e int8 9 | println(&a, &b, &c, &d, &e) 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_7.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_7.go 2 | package main 3 | 4 | import _ "unsafe" 5 | 6 | func main() { 7 | Add(1, 2) 8 | } 9 | 10 | func Add(a, b int) int 11 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_8.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_8.go 2 | package main 3 | 4 | func main() { 5 | in12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) 6 | } 7 | 8 | //go:noinline 9 | func in12(a, b, c, d, e, f, g, h, i, j, k, l int8) int8 { 10 | return a + b + c + d + e + f + g + h + i + j + k + l 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第3章 函数/code_3_9.go: -------------------------------------------------------------------------------- 1 | //第3章/code_3_9.go 2 | package main 3 | 4 | func main() { 5 | out12() 6 | } 7 | 8 | //go:noinline 9 | func out12() (a, b, c, d, e, f, g, h, i, j, k, l int8) { 10 | return 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_1.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_1.go 2 | package gom 3 | 4 | type Point struct { 5 | x float64 6 | } 7 | 8 | func (p Point) X() float64 { 9 | return p.x 10 | } 11 | 12 | func (p *Point) SetX(x float64) { 13 | p.x = x 14 | } 15 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_2.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_2.go 2 | type Point2d struct { 3 | Point 4 | y float64 5 | } 6 | 7 | func (p Point2d) Y() float64 { 8 | return p.y 9 | } 10 | 11 | func (p *Point2d) SetY(y float64) { 12 | p.y = y 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_3.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_3.go 2 | type Point2d struct { 3 | *Point 4 | y float64 5 | } 6 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_4.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_4.go 2 | package gom 3 | 4 | type A struct { 5 | a int 6 | } 7 | 8 | type B struct { 9 | b int 10 | } 11 | 12 | func (a A) Value() int { 13 | return a.a 14 | } 15 | 16 | func (a *A) Set(v int) { 17 | a.a = v 18 | } 19 | 20 | func (b B) Value() int { 21 | return b.b 22 | } 23 | 24 | func (b *B) Set(v int) { 25 | b.b = v 26 | } 27 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_5.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_5.go 2 | type C struct { 3 | A 4 | B 5 | } 6 | -------------------------------------------------------------------------------- /示例代码/第4章 方法/code_4_6.go: -------------------------------------------------------------------------------- 1 | //第4章/code_4_6.go 2 | type C struct { 3 | D 4 | B 5 | } 6 | 7 | type D struct { 8 | A 9 | } 10 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_1.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_1.go 2 | var n int 3 | var e interface{} = &n 4 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_10.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_10.go 2 | package main 3 | 4 | import ( 5 | "fmt" 6 | "strconv" 7 | "unsafe" 8 | ) 9 | 10 | type Integer int 11 | 12 | func (i Integer) Value() float64 { 13 | return float64(i) 14 | } 15 | func (i Integer) String() string { 16 | return strconv.Itoa(int(i)) 17 | } 18 | 19 | type Number interface { 20 | Value() float64 21 | String() string 22 | } 23 | 24 | func main() { 25 | i := Integer(0) 26 | fmt.Println(Methods(i)) 27 | fmt.Println(Methods(&i)) 28 | var n Number = i 29 | p := (*[5]unsafe.Pointer)((*face)(unsafe.Pointer(&n)).t) 30 | fmt.Println((*p)[3], (*p)[4]) 31 | } 32 | 33 | func Methods(a interface{}) (r []Method) { 34 | e := (*face)(unsafe.Pointer(&a)) 35 | u := uncommon(e.t) 36 | if u == nil { 37 | return nil 38 | } 39 | s := methods(u) 40 | r = make([]Method, len(s)) 41 | for i := range s { 42 | r[i].Name = name(nameOff(e.t, s[i].name)) 43 | r[i].Type = String(typeOff(e.t, s[i].mtyp)) 44 | r[i].IFn = textOff(e.t, s[i].ifn) 45 | r[i].TFn = textOff(e.t, s[i].tfn) 46 | } 47 | return 48 | } 49 | 50 | type Method struct { 51 | Name string 52 | Type string 53 | IFn unsafe.Pointer 54 | TFn unsafe.Pointer 55 | } 56 | 57 | type face struct { 58 | t unsafe.Pointer 59 | d unsafe.Pointer 60 | } 61 | 62 | //go:linkname uncommon reflect.(*rtype).uncommon 63 | func uncommon(t unsafe.Pointer) unsafe.Pointer 64 | 65 | //go:linkname methods reflect.(*uncommonType).methods 66 | func methods(u unsafe.Pointer) []method 67 | 68 | type method struct { 69 | name int32 70 | mtyp int32 71 | ifn int32 72 | tfn int32 73 | } 74 | 75 | //go:linkname nameOff reflect.(*rtype).nameOff 76 | func nameOff(t unsafe.Pointer, off int32) unsafe.Pointer 77 | 78 | //go:linkname typeOff reflect.(*rtype).typeOff 79 | func typeOff(t unsafe.Pointer, off int32) unsafe.Pointer 80 | 81 | //go:linkname textOff reflect.(*rtype).textOff 82 | func textOff(t unsafe.Pointer, off int32) unsafe.Pointer 83 | 84 | //go:linkname String reflect.(*rtype).String 85 | func String(t unsafe.Pointer) string 86 | 87 | //go:linkname name reflect.name.name 88 | func name(n unsafe.Pointer) string 89 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_11.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_11.go 2 | package inherit 3 | 4 | type A int 5 | 6 | func (a A) Value() int { 7 | return int(a) 8 | } 9 | 10 | func (a *A) Set(n int) { 11 | *a = A(n) 12 | } 13 | 14 | type B struct { 15 | A 16 | b int 17 | } 18 | 19 | type C struct { 20 | *A 21 | c int 22 | } 23 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_12.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_12.go 2 | var rw io.ReadWriter 3 | if rw == nil { 4 | println(1) 5 | } 6 | var f *os.File 7 | rw = f 8 | if rw == nil { 9 | println(2) 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_13.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_13.go 2 | type Value struct { 3 | typ unsafe.Pointer 4 | ptr unsafe.Pointer 5 | flag uintptr 6 | } 7 | 8 | func toType(p unsafe.Pointer) (t reflect.Type) { 9 | t = reflect.TypeOf(0) 10 | (*[2]unsafe.Pointer)(unsafe.Pointer(&t))[1] = p 11 | return 12 | } 13 | 14 | func main() { 15 | n := 6789 16 | s := []interface{}{ 17 | n, 18 | &n, 19 | } 20 | for i, v := range s { 21 | r := reflect.ValueOf(v) 22 | p := (*Value)(unsafe.Pointer(&r)) 23 | println(i, p.typ, p.ptr, p.flag, toType(p.typ).String()) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_14.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_14.go 2 | func main() { 3 | n := 6789 4 | v := reflect.ValueOf(&n) 5 | p := (*Value)(unsafe.Pointer(&v)) 6 | println(p.typ, p.ptr, p.flag, toType(p.typ).String()) 7 | e := v.Elem() 8 | p = (*Value)(unsafe.Pointer(&e)) 9 | println(p.typ, p.ptr, p.flag, toType(p.typ).String()) 10 | f := e.Addr() 11 | p = (*Value)(unsafe.Pointer(&f)) 12 | println(p.typ, p.ptr, p.flag, toType(p.typ).String()) 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_15.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_15.go 2 | type Number float64 3 | 4 | func (n Number) IntValue() int { 5 | return int(n) 6 | } 7 | 8 | func main() { 9 | n := Number(9) 10 | v := reflect.ValueOf(n) 11 | _ = v 12 | } 13 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_16.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_16.go 2 | func main() { 3 | n := Number(9) 4 | v := reflect.ValueOf(n) 5 | v.MethodByName("") 6 | _ = v 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_17.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_17.go 2 | func main() { 3 | n := Number(9) 4 | var a interface{} = n 5 | println(a) 6 | v := reflect.ValueOf("") 7 | v.MethodByName("") 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_18.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_18.go 2 | func main() { 3 | n := Number(9) 4 | println(n) 5 | v := reflect.ValueOf("") 6 | v.MethodByName("") 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_2.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_2.go 2 | func p2e(p *int) (e interface{}) { 3 | e = p 4 | return 5 | } 6 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_3.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_3.go 2 | n := 10 3 | var e interface{} = n 4 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_4.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_4.go 2 | func v2e(n int) (e interface{}) { 3 | e = n 4 | return 5 | } 6 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_5.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_5.go 2 | func fn(n int) bool { 3 | return notNil(n) 4 | } 5 | 6 | func notNil(a interface{}) bool { 7 | return a != nil 8 | } 9 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_6.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_6.go 2 | type A struct{} 3 | 4 | type B struct{} 5 | 6 | func (A) String() string { 7 | return "This is A" 8 | } 9 | 10 | func (B) String() string { 11 | return "This is B" 12 | } 13 | 14 | func toString(o fmt.Stringer) string { 15 | return o.String() 16 | } 17 | 18 | func main() { 19 | println(toString(A{})) // This is A 20 | println(toString(B{})) // This is B 21 | } 22 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_7.cpp: -------------------------------------------------------------------------------- 1 | //第5章/code_5_7.cpp 2 | class Type { 3 | public: 4 | virtual string Name() = 0; 5 | virtual size_t Size() = 0; 6 | }; 7 | 8 | class A : public Type { 9 | public: 10 | string Name() { 11 | return "A"; 12 | } 13 | size_t Size() { 14 | return sizeof(*this); 15 | } 16 | }; 17 | 18 | class B : public Type { 19 | public: 20 | string Name() { 21 | return "B"; 22 | } 23 | size_t Size() { 24 | return sizeof(*this); 25 | } 26 | private: 27 | int somedata; 28 | }; 29 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_8.cpp: -------------------------------------------------------------------------------- 1 | //第5章/code_5_8.cpp 2 | Type* pts[2] = {new A, new B}; 3 | for(int i = 0; i < 2; ++i) { 4 | cout << pts[i]->Name() << "," << pts[i]->Size() << endl; 5 | } 6 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/code_5_9.go: -------------------------------------------------------------------------------- 1 | //第5章/code_5_9.go 2 | f, _ := os.Open("gom.go") 3 | var rw io.ReadWriter 4 | rw = f 5 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod1/go.mod: -------------------------------------------------------------------------------- 1 | //第5章/mod1/go.mod 2 | module fengyoulin.com/mod1 3 | 4 | go 1.14 5 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod1/user.go: -------------------------------------------------------------------------------- 1 | //第5章/mod1/user.go 2 | package mod1 3 | 4 | type User struct { 5 | ID int 6 | Nick string 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod2/factory.go: -------------------------------------------------------------------------------- 1 | //第5章/mod2/factory.go 2 | package main 3 | 4 | import "fengyoulin.com/mod1" 5 | 6 | type uf struct{} 7 | 8 | func (*uf) NewUser(id int, nick string) interface{} { 9 | return &mod1.User{ 10 | ID: id, 11 | Nick: nick, 12 | } 13 | } 14 | 15 | var UserFactory uf 16 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod2/go.mod: -------------------------------------------------------------------------------- 1 | //第5章/mod2/go.mod 2 | module fengyoulin.com/mod2 3 | 4 | go 1.14 5 | 6 | require fengyoulin.com/mod1 v0.0.0 7 | 8 | replace fengyoulin.com/mod1 => /home/kylin/go/src/fengyoulin.com/mod1 9 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod3/checker.go: -------------------------------------------------------------------------------- 1 | //第5章/mod3/checker.go 2 | package main 3 | 4 | import "fengyoulin.com/mod1" 5 | 6 | type uc struct{} 7 | 8 | func (*uc) IsUser(a interface{}) bool { 9 | _, ok := a.(*mod1.User) 10 | return ok 11 | } 12 | 13 | var UserChecker uc 14 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod3/go.mod: -------------------------------------------------------------------------------- 1 | //第5章/mod3/go.mod 2 | module fengyoulin.com/mod3 3 | 4 | go 1.14 5 | 6 | require fengyoulin.com/mod1 v0.0.0 7 | 8 | replace fengyoulin.com/mod1 => /home/kylin/go/src/fengyoulin.com/mod1 9 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod4/go.mod: -------------------------------------------------------------------------------- 1 | //第5章/mod4/go.mod 2 | module fengyoulin.com/mod4 3 | 4 | go 1.14 5 | -------------------------------------------------------------------------------- /示例代码/第5章 接口/mod4/main.go: -------------------------------------------------------------------------------- 1 | //第5章/mod4/main.go 2 | package main 3 | 4 | import ( 5 | "log" 6 | "plugin" 7 | "reflect" 8 | ) 9 | 10 | type UserFactory interface { 11 | NewUser(id int, nick string) interface{} 12 | } 13 | 14 | type UserChecker interface { 15 | IsUser(a interface{}) bool 16 | } 17 | 18 | func factory() UserFactory { 19 | p, err := plugin.Open("./mod2.so") 20 | if err != nil { 21 | log.Fatalln(err) 22 | } 23 | a, err := p.Lookup("UserFactory") 24 | if err != nil { 25 | log.Fatalln(err) 26 | } 27 | uf, ok := a.(UserFactory) 28 | if !ok { 29 | log.Fatalln("not a UserFactory") 30 | } 31 | return uf 32 | } 33 | 34 | func checker() UserChecker { 35 | p, err := plugin.Open("./mod3.so") 36 | if err != nil { 37 | log.Fatalln(err) 38 | } 39 | a, err := p.Lookup("UserChecker") 40 | if err != nil { 41 | log.Fatalln(err) 42 | } 43 | uc, ok := a.(UserChecker) 44 | if !ok { 45 | log.Fatalln("not a UserChecker") 46 | } 47 | return uc 48 | } 49 | 50 | func main() { 51 | uf := factory() 52 | uc := checker() 53 | u := uf.NewUser(1, "Jack") 54 | if !uc.IsUser(u) { 55 | log.Println("not a User") 56 | } 57 | t := reflect.TypeOf(u) 58 | println(u, t.String()) 59 | select {} 60 | } 61 | -------------------------------------------------------------------------------- /示例代码/第6章 goroutine/code_6_1.go: -------------------------------------------------------------------------------- 1 | //第6章/code_6_1.go 2 | package main 3 | 4 | func hello(name string) { 5 | println("Hello ", name) 6 | } 7 | func main() { 8 | name := "Goroutine" 9 | go hello(name) 10 | } 11 | -------------------------------------------------------------------------------- /示例代码/第6章 goroutine/code_6_2.go: -------------------------------------------------------------------------------- 1 | //第6章/code_6_2.go 2 | package main 3 | 4 | import "fmt" 5 | 6 | func main() { 7 | go func(n int) { 8 | for { 9 | n++ 10 | fmt.Println(n) 11 | } 12 | }(0) 13 | for { 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /示例代码/第6章 goroutine/code_6_3.go: -------------------------------------------------------------------------------- 1 | //第6章/code_6_3.go 2 | func fibonacci(n int) int { 3 | if n < 2 { 4 | return 1 5 | } 6 | return fibonacci(n-1) + fibonacci(n-2) 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第6章 goroutine/code_6_4.go: -------------------------------------------------------------------------------- 1 | //第6章/code_6_4.go 2 | package main 3 | import "time" 4 | func hello(name string){ 5 | println("Hello ", name) 6 | } 7 | func main(){ 8 | name := "Goroutine" 9 | go hello(name) 10 | time.Sleep(time.Second) 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_1.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_1.go 2 | go func() { 3 | for { 4 | if !ok { 5 | data = someValue 6 | ok = true 7 | } 8 | } 9 | }() 10 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_2.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_2.go 2 | go func() { 3 | for { 4 | if ok { 5 | sum += data 6 | ok = false 7 | } 8 | } 9 | }() 10 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_3.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_3.go 2 | package main 3 | 4 | func main() { 5 | s := [2]chan struct{}{ 6 | make(chan struct{}, 1), 7 | make(chan struct{}, 1), 8 | } 9 | f := make(chan struct{}, 2) 10 | var x, y, a, b int64 11 | go func() { 12 | for i := 0; i < 1000000; i++ { 13 | <-s[0] 14 | x = 1 15 | b = y 16 | f <- struct{}{} 17 | } 18 | }() 19 | go func() { 20 | for i := 0; i < 1000000; i++ { 21 | <-s[1] 22 | y = 1 23 | a = x 24 | f <- struct{}{} 25 | } 26 | }() 27 | for i := 0; i < 1000000; i++ { 28 | x = 0 29 | y = 0 30 | s[i%2] <- struct{}{} 31 | s[(i+1)%2] <- struct{}{} 32 | <-f 33 | <-f 34 | if a == 0 && b == 0 { 35 | println(i) 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_4.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_4.go 2 | package main 3 | 4 | func main() { 5 | var wg sync.WaitGroup 6 | var x, y int64 7 | wg.Add(2) 8 | go func() { 9 | defer wg.Done() 10 | for i := 0; i < 1000000000; i++ { 11 | if x == 0 { 12 | if y != 0 { 13 | println("1:", i) 14 | } 15 | x = 1 16 | y = 1 17 | } 18 | } 19 | }() 20 | go func() { 21 | defer wg.Done() 22 | for i := 0; i < 1000000000; i++ { 23 | if y == 1 { 24 | if x != 1 { 25 | println("2:", i) 26 | } 27 | y = 0 28 | x = 0 29 | } 30 | } 31 | }() 32 | wg.Wait() 33 | } 34 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_5.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_5.go 2 | type Spin int32 3 | 4 | func (l *Spin) Lock() { 5 | lock((*int32)(l), 0, 1) 6 | } 7 | 8 | func (l *Spin) Unlock() { 9 | unlock((*int32)(l), 0) 10 | } 11 | 12 | func lock(ptr *int32, o, n int32) 13 | func unlock(ptr *int32, n int32) 14 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_6.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_6.go 2 | import "sync/atomic" 3 | 4 | type Spin int32 5 | 6 | func (l *Spin) Lock() { 7 | for !atomic.CompareAndSwapInt32((*int32)(l), 0, 1) { 8 | } 9 | } 10 | 11 | func (l *Spin) Unlock() { 12 | atomic.StoreInt32((*int32)(l), 0) 13 | } 14 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_7.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_7.go 2 | func (l *Spin) Lock() { 3 | for !atomic.CompareAndSwapInt32((*int32)(l), 0, 1) { 4 | pause() 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/code_7_8.go: -------------------------------------------------------------------------------- 1 | //第7章/code_7_8.go 2 | select { 3 | case v := <-ch1: 4 | println(v) 5 | case ch2 <- 10: 6 | default: 7 | } 8 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/fence.go: -------------------------------------------------------------------------------- 1 | //第7章/fence.go 2 | package main 3 | 4 | func main() { 5 | s := [2]chan struct{}{ 6 | make(chan struct{}, 1), 7 | make(chan struct{}, 1), 8 | } 9 | f := make(chan struct{}, 2) 10 | var x, y, a, b int64 11 | go func() { 12 | for i := 0; i < 1000000; i++ { 13 | <-s[0] 14 | x = 1 15 | mfence() 16 | b = y 17 | f <- struct{}{} 18 | } 19 | }() 20 | go func() { 21 | for i := 0; i < 1000000; i++ { 22 | <-s[1] 23 | y = 1 24 | mfence() 25 | a = x 26 | f <- struct{}{} 27 | } 28 | }() 29 | for i := 0; i < 1000000; i++ { 30 | x = 0 31 | y = 0 32 | s[i%2] <- struct{}{} 33 | s[(i+1)%2] <- struct{}{} 34 | <-f 35 | <-f 36 | if a == 0 && b == 0 { 37 | println(i) 38 | } 39 | } 40 | } 41 | 42 | func mfence() 43 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/fence_amd64.s: -------------------------------------------------------------------------------- 1 | //第7章/fence_amd64.s 2 | #include "textflag.h" 3 | 4 | // func mfence() 5 | TEXT ·mfence(SB), NOSPLIT, $0-0 6 | MFENCE 7 | RET 8 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/lock_amd64.s: -------------------------------------------------------------------------------- 1 | //第7章/lock_amd64.s 2 | // func lock(ptr *int32, old, new int32) 3 | TEXT ·lock(SB), NOSPLIT, $0-16 4 | MOVQ ptr+0(FP), BX 5 | MOVL old+8(FP), DX 6 | MOVL new+12(FP), CX 7 | again: 8 | MOVL DX, AX 9 | LOCK 10 | CMPXCHGL CX, 0(BX) 11 | JE ok 12 | PAUSE 13 | JMP again 14 | ok: 15 | RET 16 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/pause_amd64.s: -------------------------------------------------------------------------------- 1 | //第7章/pause_amd64.s 2 | #include "textflag.h" 3 | 4 | // func pause() 5 | TEXT pause(SB), NOSPLIT, $0-0 6 | PAUSE 7 | RET 8 | -------------------------------------------------------------------------------- /示例代码/第7章 同步/spin_amd64.s: -------------------------------------------------------------------------------- 1 | //第7章/spin_amd64.s 2 | #include "textflag.h" 3 | 4 | // func lock(ptr *int32, old, new int32) 5 | TEXT ·lock(SB), NOSPLIT, $0-16 6 | MOVQ ptr+0(FP), BX 7 | MOVL old+8(FP), DX 8 | MOVL new+12(FP), CX 9 | again: 10 | MOVL DX, AX 11 | LOCK 12 | CMPXCHGL CX, 0(BX) 13 | JE ok 14 | JMP again 15 | ok: 16 | RET 17 | 18 | // func unlock(ptr *int32, val int32) 19 | TEXT ·unlock(SB), NOSPLIT, $0-12 20 | MOVQ ptr+0(FP), BX 21 | MOVL val+8(FP), AX 22 | XCHGL AX, 0(BX) 23 | RET 24 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_1.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_1.go 2 | package main 3 | 4 | var p *int 5 | 6 | func main() { 7 | toStack(&p) 8 | toGlobal(&p) 9 | toUnknown(&p, &p) 10 | } 11 | 12 | //go:noinline 13 | func toStack(i **int) (o *int) { 14 | o = *i 15 | return 16 | } 17 | 18 | //go:noinline 19 | func toGlobal(i **int) { 20 | p = *i 21 | } 22 | 23 | //go:noinline 24 | func toUnknown(a **int, i **int) { 25 | *a = *i 26 | } 27 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_2.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_2.go 2 | package main 3 | 4 | var p *int64 5 | 6 | func main() { 7 | for i := 0; i < 1000000; i++ { 8 | p = new(int64) 9 | } 10 | time.Sleep(time.Second) 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_3.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_3.go 2 | package main 3 | 4 | var pa [10000000]*int64 5 | 6 | func main() { 7 | for i := 0; i < 10000000; i++ { 8 | pa[i] = new(int64) 9 | } 10 | time.Sleep(time.Second) 11 | } 12 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_4.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_4.go 2 | package main 3 | 4 | var pa [10000000]*int64 5 | 6 | func main() { 7 | for i := 0; i < 10000000; i++ { 8 | pa[i] = new(int64) 9 | pa[i] = new(int64) 10 | } 11 | time.Sleep(time.Second) 12 | } 13 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_5.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_5.go 2 | package main 3 | 4 | var pa [10000000]**int64 5 | 6 | func main() { 7 | for i := 0; i < 10000000; i++ { 8 | pa[i] = new(*int64) 9 | pa[i] = new(*int64) 10 | } 11 | time.Sleep(time.Second) 12 | } 13 | -------------------------------------------------------------------------------- /示例代码/第8章 堆/code_8_6.go: -------------------------------------------------------------------------------- 1 | //第8章/code_8_6.go 2 | package main 3 | 4 | var pa [10000000]*int64 5 | 6 | func main() { 7 | if err := trace.Start(os.Stdout); err != nil { 8 | log.Fatalln(err) 9 | } 10 | defer trace.Stop() 11 | for i := 0; i < 10000000; i++ { 12 | pa[i] = new(int64) 13 | pa[i] = new(int64) 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /示例代码/第9章 栈/code_9_1.go: -------------------------------------------------------------------------------- 1 | //第9章/code_9_1.go 2 | //go:noinline 3 | func test(i int) byte { 4 | var b [104]byte 5 | for x := range b { 6 | b[x] = byte(x) 7 | } 8 | return b[i%len(b)] 9 | } 10 | -------------------------------------------------------------------------------- /示例代码/第9章 栈/code_9_2.go: -------------------------------------------------------------------------------- 1 | //第9章/code_9_2.go 2 | func mc(l int) func(i int) byte { 3 | return func(i int) byte { 4 | b := make([]byte, l) 5 | for x := range b { 6 | b[x] = byte(x) 7 | } 8 | return b[i%len(b)] 9 | } 10 | } 11 | --------------------------------------------------------------------------------