go中的关键字-go(上)

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func HelloWorld() {
 8     fmt.Println("Hello goroutine")
 9 }
10 
11 func main() {
12     go HelloWorld()      // 开启一个新的并发运行
       time.Sleep(1*time.Second)
13     fmt.Println("后输出消息！")
14 }

1 Hello goroutine
2 后输出消息！

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func DelayPrint() {
 9     for i := 1; i <= 3; i++ {
10         time.Sleep(500 * time.Millisecond)
11         fmt.Println(i)
12     }
13 }
14 
15 func HelloWorld() {
16     fmt.Println("Hello goroutine")
17 }
18 
19 func main() {
20     go DelayPrint()     // 第一个goroutine
21     go HelloWorld()     // 第二个goroutine
22     time.Sleep(10*time.Second)
23     fmt.Println("main func")
24 }

1 Hello  goroutine
2 1
3 2
4 3
5 4
6 
7 main func

1 1
2 2
3 3
4 4
5 Hello goroutine
6 main function

1 package main
2 
3 func main() {
4     ch := make(chan int)
5     <- ch // 阻塞main goroutine, 通道被锁
6 }

1 fatal error: all goroutines are asleep - deadlock!
2 
3 goroutine 1 [chan receive]:
4 main.main()

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // ch1通道的数据没有被其他goroutine读取走，堵塞当前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch2 // ch2 等待数据的写
12 }

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // ch1通道的数据没有被其他goroutine读取走，堵塞当前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch1 // 取走便是
12     <- ch2 // chb 等待数据的写
13 }

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int, 3), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // cha通道的数据没有被其他goroutine读取走，堵塞当前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch2 // ch2 等待数据的写
12 }

 1 type g struct {
 2    //堆栈参数。
 3      //堆栈描述了实际的堆栈内存：[stack.lo，stack.hi）。
 4      // stackguard0是在Go堆栈增长序言中比较的堆栈指针。
 5      //通常是stack.lo + StackGuard，但是可以通过StackPreempt触发抢占。
 6      // stackguard1是在C堆栈增长序言中比较的堆栈指针。
 7      //它是g0和gsignal堆栈上的stack.lo + StackGuard。
 8      //在其他goroutine堆栈上为〜0，以触发对morestackc的调用（并崩溃）。

 9   //当前g使用的栈空间，stack结构包括 [lo, hi]两个成员
10     stack       stack   // offset known to runtime/cgo

11   // 用于检测是否需要进行栈扩张，go代码使用
12     stackguard0 uintptr // offset known to liblink

13   // 用于检测是否需要进行栈扩展，原生代码使用的
14     stackguard1 uintptr // offset known to liblink

15   // 当前g所绑定的m
16     m              *m      // current m; offset known to arm liblink

17   // 当前g的调度数据，当goroutine切换时，保存当前g的上下文，用于恢复
18     sched          gobuf

19     // goroutine运行的函数
20     fnstart        *FuncVal        
21     // g当前的状态
22     atomicstatus   uint32
23   // 当前g的id
24     goid           int64

25      // 状态Gidle,Grunnable,Grunning,Gsyscall,Gwaiting,Gdead
26     status   int16

27   // 下一个g的地址，通过guintptr结构体的ptr set函数可以设置和获取下一个g，通过这个字段和sched.gfreeStack sched.gfreeNoStack 可以把 free g串成一个链表
28     schedlink      guintptr

29   // 判断g是否允许被抢占
30     preempt        bool       // preemption signal, duplicates stackguard0 = stackpreempt

31     // g是否要求要回到这个M执行, 有的时候g中断了恢复会要求使用原来的M执行
32     lockedm        muintptr

33     // 用于传递参数，睡眠时其它goroutine设置param，唤醒时此goroutine可以获取
       param  *void

34    // 创建这个goroutine的go表达式的pc
35    uintptr    gopc
36 }

1 struct Gobuf
2 {
3     //这些字段的偏移是libmach已知的（硬编码的）。
4     sp   uintper;
5     pc   *byte;
6     g    *G;
7     ...
8 };

 1 type p struct {
 2    lock mutex
 3 
 4    id          int32
 5    // p的状态，稍后介绍
 6    status      uint32 // one of pidle/prunning/...
 7 
 8    // 下一个p的地址，可参考 g.schedlink
 9    link        puintptr
10    // p所关联的m
11    m           muintptr   // back-link to associated m (nil if idle)
12 
13    // 内存分配的时候用的，p所属的m的mcache用的也是这个
14    mcache      *mcache
15   
16    // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
17    // 从sched中获取并缓存的id，避免每次分配goid都从sched分配
18      goidcache    uint64
19      goidcacheend uint64
20 
21    // Queue of runnable goroutines. Accessed without lock.
22    // p 本地的runnbale的goroutine形成的队列
23    runqhead uint32
24    runqtail uint32
25    runq     [256]guintptr
26 
27    // runnext，如果不是nil，则是已准备好运行的G
28    //当前的G，并且应该在下一个而不是其中运行
29    // runq，如果运行G的时间还剩时间
30    //切片。它将继承当前时间剩余的时间
31    //切片。如果一组goroutine锁定在
32    //交流等待模式，该计划将其设置为
33    //单位并消除（可能很大）调度
34    //否则会由于添加就绪商品而引起的延迟
35    // goroutines到运行队列的末尾。
36 
37    // 下一个执行的g，如果是nil，则从队列中获取下一个执行的g
38    runnext guintptr
39 
40    // Available G's (status == Gdead)
41    // 状态为 Gdead的g的列表，可以进行复用
42    gfree    *g
43    gfreecnt int32
44 }

 1 type m struct {
 2      // g0是用于调度和执行系统调用的特殊g
 3    g0      *g             // goroutine with scheduling stack
 4      // m当前运行的g
 5    curg    *g             // current running goroutine
 6    // 当前拥有的p
 7    p        puintptr      // attached p for executing go code (nil if not executing go code)

 8    // 线程的 local storage
 9    tls      [6]uintptr    // thread-local storage
10    // 唤醒m时，m会拥有这个p
11    nextp         puintptr
12    id            int64
13    // 如果 !="", 继续运行curg
14    preemptoff    string   // if != "", keep curg running on this m

15    // 自旋状态，用于判断m是否工作已结束，并寻找g进行工作
16    spinning      bool     // m is out of work and is actively looking for work

17    // 用于判断m是否进行休眠状态
18    blocked       bool     // m is blocked on a note
19    // m休眠和唤醒通过这个，note里面有一个成员key，对这个key所指向的地址进行值的修改，进而达到唤醒和休眠的目的
20    park          note

21    // 所有m组成的一个链表
22    alllink       *m       // on allm
23    // 下一个m，通过这个字段和sched.midle 可以串成一个m的空闲链表
24    schedlink     muintptr
25    // mcache，m拥有p的时候，会把自己的mcache给p
26    mcache        *mcache
27    // lockedm的对应值
28    lockedg       guintptr
29    // 待释放的m的list，通过sched.freem 串成一个链表
30    freelink      *m      // on sched.freem
31 }

 1 type schedt struct {
 2    // 全局的go id分配
 3    goidgen  uint64
 4    // 记录的最后一次从i/o中查询g的时间
 5    lastpoll uint64
 6 
 7    lock mutex
 8 
 9    //当增加nmidle，nmidlelocked，nmsys或nmfreed时，应
10    //确保调用checkdead（）。
11 
12      // m的空闲链表，结合m.schedlink 就可以组成一个空闲链表了
13    midle        muintptr // idle m's waiting for work
14    nmidle       int32    // number of idle m's waiting for work
15    nmidlelocked int32    // number of locked m's waiting for work
16    // 下一个m的id，也用来记录创建的m数量
17    mnext        int64    // number of m's that have been created and next M ID
18    // 最多允许的m的数量
19    maxmcount    int32    // maximum number of m's allowed (or die)
20    nmsys        int32    // number of system m's not counted for deadlock
21    // free掉的m的数量，exit的m的数量
22    nmfreed      int64    // cumulative number of freed m's
23 
24    ngsys uint32 // 系统goroutine的数量；原子更新
25 
26    pidle      puintptr // 闲置的
27    npidle     uint32
28    nmspinning uint32 // See "Worker thread parking/unparking" comment in proc.go.
29 
30    // Global runnable queue.
31    // 这个就是全局的g的队列了，如果p的本地队列没有g或者太多，会跟全局队列进行平衡
32    // 根据runqhead可以获取队列头的g，然后根据g.schedlink 获取下一个，从而形成了一个链表
33    runqhead guintptr
34    runqtail guintptr
35    runqsize int32
36 
37    // freem是m等待被释放时的列表
38    //设置了m.exited。通过m.freelink链接。
39 
40    // 等待释放的m的列表
41    freem *m
42 }