arr1 := [3]int{1, 2, 3} // 上限推导
arr2 := [...]{1, 2, 3} // 语句转化

[]int
[]interface{}

type SliceHeader struct{
    Data uintptr  // 指向数组的指针， 因为数组不允许扩充，所以 Slice 扩充时需要新开辟一个数组的空间
    Len int
    Cap int // 总容量
}

    list := []int{1, 2, 3, 4}
    list2 := []int{5, 6, 7, 8}
    list := append(list, 0) // 追加
    list := append([]int{0}, list) // 头插入
    list := append(list, list2...) // 合并
    list := append(list[:4], list[5:]...) // 删除
    list := append(list[:4], append([]int{0}, list[:4]...)...) // 插入

type hmap struct {
    count     int
    flags     uint8
    B         uint8
    noverflow uint16
    hash0     uint32

    buckets    unsafe.Pointer
    oldbuckets unsafe.Pointer
    nevacuate  uintptr

    extra *mapextra
}

// 字面量
hash := map[string]int{
    "1": 2,
    "3": 4,
    "5": 6,
}
// 运行时
hash := make(map[string]int, 3)

for k, v := range hash {  // 遍历
    // k, v
}
hash[key] = value  // 写入
delete(hash, key)  // 删除
v := hash[key]  // 读取
v, ok := hash[key]  // 读取

type StringHeader struct {
    Data uintptr
    Len  int
} 

package main

func main() {
    type Test struct{}
    v := Test{}
    Print(v) // (0x1063640,0x10f68e8)  
}

func Print(v interface{}) { // 传入的参数将会发生 隐性类型转换
    println(v)
}

type Cat struct {}
type Duck interface { ... }

func (c  Cat) Quack {}  // 使用结构体实现接口
func (c *Cat) Quack {}  // 使用结构体指针实现接口

var d Duck = Cat{}      // 使用结构体初始化变量
var d Duck = &Cat{}     // 使用结构体指针初始化变量

package main

type TestStruct struct{}

func NilOrNot(v interface{}) bool {
    return v == nil
}

func main() {
    var s *TestStruct
    fmt.Println(s == nil)      // #=> true
    fmt.Println(NilOrNot(s))   // #=> false
}

type eface struct { // 16 bytes
    _type *_type
    data  unsafe.Pointer
}

type str interfcae{}
func main(){
    a := "hello"
    print(a)

}

func print(v str){
    fmt.Println(v.(type))
}

type Type interface {
        Align() int
        FieldAlign() int
        Method(int) Method  // 返回第i个方法
        MethodByName(string) (Method, bool)  // 可以获得当前累心对应方法的引用
        NumMethod() int
        ...
        Implements(u Type) bool  // 可以判断当前类型是否实现了某个接口
        ...
}

type Value struct {
        // contains filtered or unexported fields
}

func (v Value) Addr() Value  // 获取v的地址指针, (如果v的底层值是unaddressable类型则会panic)
func (v Value) Bool() bool  // 获取v的bool值，(如果v的底层值不是bool类型则会panic)
func (v Value) Bytes() []byte  // 获取vbytes底层值，（如果v的底层值不是字节片段，则会panic）
...

func main() {
    i := 1
    v := reflect.ValueOf(i)
    v.SetInt(10)
    fmt.Println(i)
}

panic: reflect: reflect.flag.mustBeAssignable using unaddressable value

func main() {
    i := 1
    v := reflect.ValueOf(&i)
    v.Elem().SetInt(10)
    fmt.Println(i)
}

$ go run reflect.go
10

func main() {
    arr := []int{1, 2, 3}
    for _, v := range arr {
        arr = append(arr, v)
    }
    fmt.Println(arr)
}

$ go run main.go
1 2 3 1 2 3

// 对于所有的 range 循环，Go 语言在编译器期间会转换成经典的三段式 for 循环, 而 循环的起始与终止的索引循环开始之前就已经被确定了。

func main() {
    a := [...]int{1, 2, 3}
    for i, v := range a {
        if i == 0 {
            a[1] = 10
        }
        fmt.Printf("%d: %d - %d \n", i, a[i], v)
    }
}

$ go run main.go
0: 1 - 1 
1: 10 - 2 
2: 3 - 3 

// 对于所有的 range 循环，Go 会复制出一份循环体ha，用于遍历, 而这里的 v 指向的便是ha中的一个元素
// 不过需要主要，这个例子中循环体是数组

func main() {
    arr := []int{1, 2, 3}
    newArr := []*int{}
    for _, v := range arr {
        newArr = append(newArr, &v)
    }
    for _, v := range newArr {
        fmt.Println(*v)
    }
}

$ go run main.go
3 3 3
// 对于 for _, v := range xxx 中，
// 每个循环体的值都会被赋值于同一个新变量 v (所以 循环中v拥有同样的地址空间),
// 正确的做法应该是使用 &arr[i] 替代 &v

func main() {
    arr := []int{1, 2, 3}
    for i, _ := range arr {
        arr[i] = 0
    }
}

func main() {
    a := map[int]int{
        1: 1,
        2: 2,
        3: 3,
    }
    for k, v := range a{
        fmt.Print(k, v, "|")
    }
    fmt.Println()
    for k, v := range a{
        fmt.Print(k, v, "|")
    }
}

$ go run main.go
2 2|3 3|1 1|
1 1|2 2|3 3|
// Go 在使用 for range 遍历map时 会获得随机的key顺序
// 这是 Go 语言故意的设计, 为了让使用者不依赖与go的顺序

for Ninit; Left; Right{
    NBody
}

var v1, v2 *Node
...
ha := a  // 原始的切片被赋值给 ha
hv1 := 0
hn := len(ha)  // 遍历的终止条件在遍历前就被确定
v1 := hv1  // v1 是每次循环的 index 值
for ; hv1 < hn; hv1++ {
    tmp := ha[hv1]  // 循环实际上读取的 被拷贝出来的切片 ha
    v1, v2 = hv1, tmp  // 利用 v2 获取每次变量的值(v2的地址实际已经固定)
    ...
}

ha := a  // 和遍历切片一样， 依旧会被赋值给 ha
hit := hiter(n.Type)
th := hit.Type
mapiterinit(typename(t), ha, &hit)  // mapiterinit 会初始化遍历开始的元素
for ; hit.key != nil; mapiternext(&hit) {  // mapiternext 则会获得下一个被遍历的元素
    key := *hit.key
    val := *hit.val
}

ha := s
for hv1 := 0; hv1 < len(ha); {
    hv1t := hv1
    hv2 := rune(ha[hv1])
    if hv2 < utf8.RuneSelf {  // 这里是为了判断 字节是否达到 utf8 的数位
        hv1++
    } else {
        hv2, hv1 = decoderune(h1, hv1)  // 将读取到的字节转成 rune
    }
    v1, v2 = hv1t, hv2
}

ha := a
hv1, hb := <-ha
for ; hb != false; hv1, hb = <-ha {
    v1 := hv1
    hv1 = nil
    ...
}

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

func main() {
    ctx, channel := context.WithTimeout(context.Background(), 1000*time.Millisecond)
    defer channel()
    go handle(ctx)
    select {
    case <-time.After(3 * time.Second):
        fmt.Println("main end")
    }
}

func handle(ctx context.Context) {
    select {
    case <-ctx.Done():
        fmt.Println("handle", ctx.Err())
    case <-time.After(1500 * time.Millisecond):
        fmt.Println("handle end")
    }
    time.Sleep(1 *time.Second)
    fmt.Println("sleep 1 Second")
}

// $ go run main.go
handle context deadline exceeded
sleep 1 Second
main end

TODO

type valueCtx struct {
    Context
    key, val interface{}
}

func (c *valueCtx) Value(key interface{}) interface{} {
    if c.key == key {
        return c.val
    }
    return c.Context.Value(key)    // 这个方法解决了使用 父 Context 携带数据的问题, 如果自己没有携带这个值， 就交给父Context 去处理。
}

type Mutex struct {
    state int32    // 标示当前互斥锁的状态
    sema  uint32   // 用于控制锁状态的信号量
}

var mutex sync.Mutex
var x = 0

func main() {
    for i := 0; i < 10; i++ {
        go xAdd()
    }
    time.Sleep(1 * time.Second)
}

func xAdd() {
    mutex.Lock()
    defer mutex.Unlock()  // 如果未上锁的时候解锁会触发 Panic
    x = x + 1
    fmt.Println(x)
}

type RWMutex struct {
    w           MutexA  // 提供互斥锁能力
    writerSem   uint32  // 用于写等待读
    readerSem   uint32  // 用于读等待写
    readerCount int32   // 存储了当前正在执行读操作的数量
    readerWait  int32   // 标示当写操作被阻塞时等待读操作的个数
}

requests := []*Request{...}
wg := &sync.WaitGroup{}
wg.Add(len(requests))  // 增加 wg的等待个数

for _, request := range requests {
    go func(r *Request) {
        defer wg.Done()  // 当完成后减少 wg 的等待个数 
        // res, err := service.call(r)
    }(request)
}
wg.Wait()  // 当所有的 wg 都完成之后，程序继续进行

type WaitGroup struct {
    noCopy noCopy  // noCopy 用于保证waitGroup 创建后不会被拷贝
    state1 [3]uint32 // 保存状态与信号量
}

func main() {
    o := &sync.Once{}
    for i := 0; i < 10; i++ {
        o.Do(func() {
            fmt.Println("only once")
        })
    }
}

$ go run main.go
only once

type Once struct {
    done uint32  // 标识是否执行过
    m    Mutex   // 用于并发执行时只执行一次
}

// 设定超时
func WaitChannel(conn <-chan string) bool {
    timer := time.NewTimer(1 * time.Second)

    select {
    case <- conn:
        timer.Stop()
        return true
    case <- timer.C: // 超时
        println("WaitChannel timeout!")
        return false
    }
}

// 延时函数  
func DelayFunction() {
    timer := time.NewTimer(5 * time.Second)

    select {
    case <- timer.C:
        log.Println("Delayed 5s, start to do something.")
    }
}

type timer struct {
    pp puintptr

    when     int64        // 当计时器被唤醒的时间；
    period   int64        // 两次被唤醒的间隔；
    f        func(interface{}, uintptr)    // 每个计时器被唤醒都会调用的函数
    arg      interface{}  // 计时器被唤醒时调用 f 传入的参数；
    seq      uintptr     
    nextwhen int64        // 计时器处于 timerModifiedXX 状态时， 用于设置 when 字段；
    status   uint32       // 计时器的状态；
}

type p struct {
    ...
    timersLock mutex
    timers []*timer

    numTimers     uint32
    adjustTimers  uint32
    deletedTimers uint32
    ...
}

type Timer struct {
    C <-chan Time
    r runtimeTimer
}

// src/runtime/chan.go
type hchan struct {
    qcount   uint           // 队列中的所有数据数
    dataqsiz uint           // 环形队列的大小
    buf      unsafe.Pointer // 指向大小为 dataqsiz 的数组缓冲区的指针
    elemsize uint16         // 元素大小
    closed   uint32         // 是否关闭
    elemtype *_type         // 元素类型
    sendx    uint           // Channel 的发送操作 处理到的索引 (发送索引)
    recvx    uint           // Channel 的接受操作 处理到的索引 (接受索引)
    recvq    waitq          // recv 等待列表，即（ <-ch ） 
    sendq    waitq          // send 等待列表，即（ ch<- ）
    lock mutex
}
type waitq struct { // 等待队列 sudog 双向队列
    first *sudog  // sudog 是一个链式队列
    last  *sudog
}

func makechan(t *chantype, size int) *hchan {
    elem := t.elem

    // 判断是否溢出
    mem, overflow := math.MulUintptr(elem.size, uintptr(size))
    if overflow || mem > maxAlloc-hchanSize || size < 0 {
        panic(plainError("makechan: size out of range"))
    }

    var c *hchan
    switch {
    case mem == 0:             // 元素不具有内存空间 (int ...)
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        c.buf = c.raceaddr()
    case elem.ptrdata == 0:    // 元素不包含指针
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        c.buf = add(unsafe.Pointer(c), hchanSize)
    default:  // 元素包含指针
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }
    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    c.dataqsiz = uint(size)
    return c
}

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    // 当向 nil channel 发送数据时，会调用 gopark
    // 而 gopark 会将当前的 Goroutine 休眠，从而发生死锁崩溃
    if c == nil {
        if !block {
            return false
        }
        gopark(nil, nil, waitReasonChanSendNilChan)  // 使得当前 Groutine 休眠
        throw("unreachable")
    }

    ...
}

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    ...
    lock(&c.lock)  // 上锁

    if c.closed != 0 {  // 判断 channel 是否关闭， 如果关闭则引发 panic("send on closed channel")
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }
    ...
}

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    ...
    if sg := c.recvq.dequeue(); sg != nil {         // 判断 recvq.dequeue() 是否为空, 即判断等待队列是否存在 Goroutine
        send(c, sg, ep, func() { unlock(&c.lock) }) // 发送并解锁
        return true                                 // 结束函数
    } 
    ...
}

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    ...
    if c.qcount < c.dataqsiz {      // 判断缓存区剩余大小是否大于 type 类型的大小
        qp := chanbuf(c, c.sendx)   // 根据发送索引获得缓冲区的指针
        if raceenabled {
            raceacquire(qp)
            racerelease(qp)
        }
        typedmemmove(c.elemtype, qp, ep)  // 将数据拷贝到缓冲区指针中
        c.sendx++                         // 缓冲区列表发送索引 + 1
        if c.sendx == c.dataqsiz {        // 若索引越界则置零
            c.sendx = 0
        }
        c.qcount++                // 完成存入，记录增加的数据，解锁
        unlock(&c.lock)           // 解锁
        return true               // 结束函数
    }
    ...
}

    gp := getg()  // 获取当前 Goroutine 的指针
    mysg := acquireSudog()  // 分配 sudog , 
                            // mysg 是一个封装了 g 指针的结构体， 用于表示阻塞的 Goroutine 
    // 配置 当前线程的 sudog
    mysg.releasetime = 0  
    if t0 != 0 {
        mysg.releasetime = -1
    }
    mysg.elem = ep   // 装填 要 发送的信息
    mysg.waitlink = nil
    mysg.g = gp      // 装填 当前 Goroutine 指针
    mysg.isSelect = false  // 设置 非 Select 模式 下
    mysg.c = c       // 将 channel 关联到 sudog

    // 因为调度器在停止当前 g 的时候会记录运行现场，当恢复阻塞的发送操作时候，会从此处继续开始执行

    gp.waiting = mysg  // 传入需要等待的阻塞
    gp.param = nil     
    c.sendq.enqueue(mysg)  // 将 阻塞mysg 加入发送等待队列

    // 将 Goroutine 陷入休眠 当唤醒后 执行 chanparkcommit  
    // 其实这里就是在等待 <- chan 接受信息了, 接受函数会从 channel 的 sendq 中取到 mysg 然后拿到 传递的数据
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2) 
    KeepAlive(ep)   // 保证ep不被释放

    if mysg != gp.waiting {      // 守卫: 验证已经脱离等待, 其实很少需要验证, 接受chan消息的函数 会将其置 nil
        throw("G waiting list is corrupted")
    }
    gp.waiting = nil
    gp.activeStackChans = false
    if gp.param == nil {
        if c.closed == 0 {      //  正常唤醒状态，Goroutine 应该包含需要传递的参数，但如果没有唤醒时的参数，且 channel 没有被关闭，则为虚假唤醒
            throw("chansend: spurious wakeup")
        }
        panic(plainError("send on closed channel"))
    }
    gp.param = nil  
    if mysg.releasetime > 0 {
        blockevent(mysg.releasetime-t0, 2)
    }
    mysg.c = nil        // 取消与之前阻塞的 channel 的关联
    releaseSudog(mysg)  // 释放 阻塞对象
    return true         // 结束

func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    if raceenabled {  // raceenable 是 const 且为 false, 所以一般一下代码不会执行。
        ...
    }
    if sg.elem != nil {                  // 若接受 sudog 存在指针 (指向某片空间) 可以接受数据; 
                                         // 这个判断主要过滤掉 `<- chan`

        sendDirect(c.elemtype, sg, ep)   // 向sg 发送 ep 数据
        sg.elem = nil                   // sudog 对象释放指针
    }
    gp := sg.g      // 获取 Goroutine 指针
    unlockf()       // 解锁 当前 channel
    gp.param = unsafe.Pointer(sg)  // param 是 Goroutine 唤醒 传参
    if sg.releasetime != 0 {   
        sg.releasetime = cputicks()
    }
    goready(gp, skip+1)  // 将 gp 作为下一个立即被执行的 Goroutine
}

func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
    dst := sg.elem              // copy 接受指针
    typeBitsBulkBarrier(t, uintptr(dst), uintptr(src), t.size)  // 写屏障 (作为原子操作) 避免内存资源竞争
    memmove(dst, src, t.size)  // 两块内存区域复制, 尺寸为 t.size
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    if c == nil {  //  判断 ch 是否为空
        if !block {
            return
        }
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }
}

    // 判断 ch 是否异常(没有正常的初始化)
    if !block && (c.dataqsiz == 0 && c.sendq.first == nil ||
        c.dataqsiz > 0 && atomic.Loaduint(&c.qcount) == 0) &&
        atomic.Load(&c.closed) == 0 {
        return
    }

    var t0 int64
    if blockprofilerate > 0 {
        t0 = cputicks()
    }

    lock(&c.lock)
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    lock(&c.lock)  // 为 ch 上锁
    ...
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    if c.closed != 0 && c.qcount == 0 {  // 若 ch 已经关闭则解锁退出
        if raceenabled {...}   //  const raceenabled = false  所以不必理睬
        unlock(&c.lock)A  // 解锁
        if ep != nil {
            typedmemclr(c.elemtype, ep)  // 释放 ch 缓冲区空间; 释放 ep  指针空间; (ep - 接收指针 : ep <- ch)
        }
        return true, false
    }
    ...
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    if sg := c.sendq.dequeue(); sg != nil {             // 若发送队列中存在阻塞的 sudog
        recv(c, sg, ep, func() { unlock(&c.lock) }, 3)  // 直接接受并解锁
        return true, true                               // 退出
    }
    ...
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    if c.qcount > 0 {                     // 若 channel 的缓冲区存在信息
        qp := chanbuf(c, c.recvx)         // 通过接受索引 获取到 一个 发送信息的地址指针
        if raceenabled { ... }            //  const raceenabled = false
        if ep != nil {                    // 若 接受指针存在内存空间 则 qp 内存信息 复制给 ep
            typedmemmove(c.elemtype, ep, qp)  // 将 qp 指向的信息复制给 ep
        }
        typedmemclr(c.elemtype, qp)       // 释放 qp 内存信息
        c.recvx++                         // 接受索引+1
        if c.recvx == c.dataqsiz {        // 若接受索引等于 ch 的 缓冲区大小，则置零
            c.recvx = 0
        }
        c.qcount--                        // 缓冲区内信息个数 - 1
        unlock(&c.lock)                   // 解锁
        return true, true                 // 退出
    }  ...
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    ...
    if !block {            // 解锁当前 ch
        unlock(&c.lock)
        return false, false
    }

    gp := getg()           // 获得当前 Goroutine 的指针
    mysg := acquireSudog() // 创建 sudog

    // 初始化 sudog (与 发送函数类似)
    mysg.releasetime = 0    
    if t0 != 0 {
        mysg.releasetime = -1
    }
    mysg.elem = ep        // 配置将接受指针指向的地址空间 交给 elem
    mysg.waitlink = nil   
    gp.waiting = mysg     // gp 设置成阻塞状态
    mysg.g = gp           // 将 sudog 装填 当前 Gorotuine
    mysg.isSelect = false // 非 select
    mysg.c = c            // 装填 ch
    gp.param = nil        // 没有唤醒传参
    c.recvq.enqueue(mysg) // 将 sudog 写入 ch 的接受等待队列

    // 阻塞当前 Goroutine
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)

    // 唤醒后:
    if mysg != gp.waiting {  // 守卫：判断 gp.waiting 是否为当前线程的阻塞信息,  panic
        throw("G waiting list is corrupted")
    }
    gp.waiting = nil                 //  清空 gp 的 阻塞状态
    gp.activeStackChans = false      
    if mysg.releasetime > 0 {
        blockevent(mysg.releasetime-t0, 2)
    }
    closed := gp.param == nil       // 
    gp.param = nil                  // 清空 gp 的 唤醒传参
    mysg.c = nil                    // 清空 sudo 持有的 ch
    releaseSudog(mysg)              // 释放 sudog
    return true, !closed            // 退出
}

func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    if c.dataqsiz == 0 {          // 若 ch 缓存区 为空
        if raceenabled {...}      // const raceenabled = false
        if ep != nil {            //  若 ep 存在地址空间, 直接复制
            recvDirect(c.elemtype, sg, ep)  // 加锁; 复制内存
        }
    } else {    // 从缓存区拷贝
        qp := chanbuf(c, c.recvx)  //通过 接受索引 获得 缓存区一条信息的地址空间指针 qp
        if raceenabled {...}       //  const raceenabled = false
        if ep != nil {             // 若 ep 存在地址空间
            typedmemmove(c.elemtype, ep, qp) // 将 qp 的信息赋给 ep
        }
        typedmemmove(c.elemtype, qp, sg.elem)  // 将 发送 sudog 的 信息 赋值给 qp (缓冲区上的一个槽)
        c.recvx++                              // 接受索引+1
        if c.recvx == c.dataqsiz {             // 当接受索引等于缓冲区大小后置零
            c.recvx = 0
        }
        c.sendx = c.recvx            // c.sendx = (c.sendx+1) % c.dataqsiz
    }
    sg.elem = nil                    //清空  发送 sudog 携带的 信息
    gp := sg.g                       // 获取 sudog 携带的 被阻塞的 Goroutine 指针 ， 赋值给 gp
    unlockf()                        // 解锁
    gp.param = unsafe.Pointer(sg)    // gp 传入取消阻塞传参 sg
    if sg.releasetime != 0 {
        sg.releasetime = cputicks()
    }
    goready(gp, skip+1)             // 唤醒 gp (发送方被阻塞的 Goroutine)
}

func closechan(c *hchan) {
    if c == nil {       // 判断 ch 是否为空 ; panic
        panic(plainError("close of nil channel"))
    }

    lock(&c.lock)            // 上锁
    if c.closed != 0 {       // 判断 ch 是否已经被关闭
        unlock(&c.lock)      // 解锁 并 panic
        panic(plainError("close of closed channel"))
    }

    if raceenabled { ... }    // const raceenabled = false 
    ...
    c.closed = 1             // 给 ch 设置 释放标志
}

func closechan(c *hchan) {
    ...
    var glist gList               // glist 存放因为接受或发送信息被阻塞的 Goroutine

    for {  // 循环释放
        sg := c.recvq.dequeue()   // 获取等待队列的 sudog
        if sg == nil {            // sudog 为 nil  退出循环体
            break
        }
        if sg.elem != nil {       // 若 sudog 接受数据的指针不为空(存在地址空间)
            //  释放 sudog 的 接受数据指针的地址
            typedmemclr(c.elemtype, sg.elem) 
            sg.elem = nil
        }
        if sg.releasetime != 0 {
            sg.releasetime = cputicks()
        }
        gp := sg.g                  // 取出 被阻塞的 Goroutine
        gp.param = nil              // 唤醒传参置为 nil
        if raceenabled {...}
        glist.push(gp)              // Goroutine 压入 glist
    }
    ...
}

func closechan(c *hchan) {
    ...
    for {          // 循环释放
        sg := c.sendq.dequeue()   // 获取发送队列的 sudog

        // 与释放接受队列类似 
        if sg == nil {            // sudog 为 nil  退出循环体
            break
        }
        sg.elem = nil
        if sg.releasetime != 0 {
            sg.releasetime = cputicks()
        }
        gp := sg.g              // 取出 被阻塞的 Goroutine
        gp.param = nil          // 唤醒传参置为 nil 
        if raceenabled {..}
        glist.push(gp)          // Goroutine 压入 glist 
    }
    ... 
}

func closechan(c *hchan) {
    ...
    unlock(&c.lock)  // 解锁 ch

    for !glist.empty() {   // 循环到 glist 全部被弹出
        gp := glist.pop()  // 弹出一个需要唤醒的 Goroutine
        gp.schedlink = 0
        goready(gp, 3)     // 唤醒 Goroutine
    }
}

type g struct {
    stack       stack   // 执行栈, 描述了当前Goroutine 的栈内存范围 (lo ~ hi)
    stackguard0 uintptr // 用于检测堆栈是否溢出(扩容或抢占)
    stackguard1 uintptr // 用于检测C堆栈是否溢出

    _panic       *_panic // 指向 panic栈 最内测的对象
    _defer       *_defer // 指向 defer(延迟函数) 最内测的对象

    m            *m      // 当前 Goroutine 占用的 M (可能为空)
    sched        gobuf   // pc, sp, lr 等上下文数据
    ...
    param        unsafe.Pointer
    stktopsp     uintptr        // sp期望栈顶, 用于回溯检查
    param        unsafe.Pointer // 唤醒时候传递的参数
    atomicstatus uint32         // Goroutine 状态(_Gidle, _Grunnable, _Grunning ...)
    stackLock    uint32         // stack Lock
    goid         int64          // Goroutine Id 对开发者不可见，Go 团队认为引入 ID 会让部分 Goroutine 变得更特殊，从而限制语言的并发能力；
    ...
    waitsince    int64          // 阻塞的开始时间
    waitreason   waitReason     // 阻塞的原因
    preempt       bool          // 抢占信号
    ...
    timer         *timer        // 为 time.Sleep 缓存的计时器
    ...
}

type stack struct {       // 用于描述 Go 的执行栈
    lo uintptr            // 下边界
    hi uintptr            // 上边界
}

type gobuf struct {       // 用于 保存、恢复 上下文
    sp   uintptr          // 栈指针
    pc   uintptr          // 程序计数器
    g    guintptr         // 持有 gobuf 的 g 指针
    ctxt unsafe.Pointer
    ret  sys.Uintreg      // 系统调用的返回值
    ...
}

type m struct {
    g0      *g                 // m 持有的 Goroutine 用于执行调度指令
    ...
    procid        uint64       // 底层线程id (PID)
    gsignal       *g           //  处理 signal 的 Goroutine
    ...
    tls           [6]uintptr   // 本地线程存储 (传给 FS寄存器的线程局部存储)
    mstartfn      func()       // m 启动时的函数
    curg          *g           // 当前正在运行( 执行代码 ) 的 Goroutine
    ...
    p             puintptr     // m 执行代码时持有的 p (没有执行代码时为 nil )
    nextp         puintptr     // 暂存的 p
    oldp          puintptr     // 执行系统调用之前使用 执行程序的 p
    id            int64        // id
    spinning      bool         // m 没有可以执行的 g, 正在寻找可以执行的 g (自旋 spin)； 其实 m 就两个状态 自旋(spinning) 和 运行(runing)
    ...
    incgo         bool         // m 正在执行 CGO 调用
    ...
    mcache        *mcache      // 运行代码是 绑定的 p 的 mache
    ...
}

type p struct {
    id            int32        // p id
    status        uint32       // p 的状态; _Pidle, _Prunning...
    ...
    m             muintptr     // 反向链接到关联的 m （nil 则表示 idle）
    mcache        *mcache      // pre-p的分配cache
    pcache        pageCache    // 页面缓存
    ...
    deferpool     [5][]*_defer // 不同大小的可用的 defer 结构池
    deferpoolbuf  [5][32]*_defer
    runqhead      uint32       // p 的运行队列头
    runqtail      uint32       // p 的运行队列尾
    runq          [256]guintptr// p 的运行队列
    runnext       guintptr     // 下一个需要执行的 Goroutine
    gFree struct {
        gList
        n int32
    }
    ...
    palloc persistentAlloc // per-P to avoid mutex
    gcw gcWork
    ...
}

func schedinit() {
    _g_ := getg()            // 获取当前 Goroutine
    if raceenabled { ... }   // const raceenabled = false
    sched.maxmcount = 10000  // 设置最大线程数 10000；  Go 语言启动最大线程数为 10000
    tracebackinit()          // traceback 初始化
    moduledataverify()       // moduleData 验证
    stackinit()              // 堆栈初始化
    mallocinit()             // 内存分配初始化
    fastrandinit()           // 随机数模块初始化 
    mcommoninit(_g_.m)       // M 初始化
    cpuinit()                // 初始化 cpu 相关的配置信息
    alginit()                // algebra(代数模块)初始化
    modulesinit()            // 初始化活跃的 模块
    typelinksinit()          // 初始化类型链接
    itabsinit()              // 初始化 itabs
    msigsave(_g_.m)          // 将信号遮码保存到 主线程 m
    initSigmask = _g_.m.sigmask  // 初始化信号遮罩
    goargs()                 // 获得运行传参
    goenvs()                 // 获得环境信息
    parsedebugvars()         // 解析调试变量
    gcinit()                 // gc 初始化
    sched.lastpoll = uint64(nanotime())    // 初始化上次网络轮训时间
    procs := ncpu                          // P 数量设置成 cpu 数量
    if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {  // 如果有全局设置，则 P 数量设置为 GOMAXPROCS 
        procs = n                           
    }
    if procresize(procs) != nil {  // 调整 P 的数量（ P 初始化 )
        throw("unknown runnable goroutine during bootstrap")
    }
    ...
}

func mcommoninit(mp *m) {
    _g_ := getg()                             // 获得当前 Goroutine
    if _g_ != _g_.m.g0 {
        callers(1, mp.createstack[:])         // 如果 当前线程不是 M 的 g0, 创建堆栈
    }
    lock(&sched.lock)                         // 上锁
    if sched.mnext+1 < sched.mnext {          // 守卫: 判断 线程数是否溢出
        throw("runtime: thread ID overflow")
    }
    mp.id = sched.mnext                       // 给 m 设置 id (实际上是当前 m 的创建序列)
    sched.mnext++                             // mnext ++
    checkmcount()                             // 守卫: 判断 m 数量是否超过 限制（默认10000）

    // 初始化 m 随机数
    mp.fastrand[0] = uint32(int64Hash(uint64(mp.id), fastrandseed))
    mp.fastrand[1] = uint32(int64Hash(uint64(cputicks()), ^fastrandseed))
    if mp.fastrand[0]|mp.fastrand[1] == 0 {
        mp.fastrand[1] = 1
    }

    mpreinit(mp)                             // 为 m 初始化一个 专门处理信号的 g
    if mp.gsignal != nil {
        mp.gsignal.stackguard1 = mp.gsignal.stack.lo + _StackGuard
    }

    // 添加到 allm 中，从而当它刚保存到寄存器或本地线程存储时候 GC 不会释放 g.m  
    // 这里 allm 指向最后一个 m ，它用于将新的 m 的 allink 引导指向 上一个 m, 在将 allm 指向最新的 m； 这样所有的 m 就链接起来了
    mp.alllink = allm 
    atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))

    unlock(&sched.lock)   // 解锁

    if iscgo || GOOS == "solaris" || GOOS == "illumos" || GOOS == "windows" {  // 若 GC 奔溃， 分配内存保存 TraceBack
        mp.cgoCallers = new(cgoCallers)
    }

func procresize(nprocs int32) *p {
    old := gomaxprocs                     // 获得Go启动后 P 的最大数量数量
    if old < 0 || nprocs <= 0 {           // 守卫: 判断 p 数量是否异常
        throw("procresize: invalid arg")
    }
    if trace.enabled {                    // 记录Trace事件
        traceGomaxprocs(nprocs)
    }
    now := nanotime()                     // 获取当前系统时间
    if sched.procresizetime != 0 {        // 记录 p 总用时: (当前时间 - 上次更改 p 的时间) * p 数量 + 上次记录的总用时
        sched.totaltime += int64(old) * (now - sched.procresizetime)
    }
    sched.procresizetime = now            // 记录最后一次更改 p 数量的时间

    // 该函数的主要部分 ：更新 p 的数量
    if nprocs > int32(len(allp)) {        // 若预期 p 的数量大于当前运行的 p 的数量 (allp 是个切片)
        lock(&allpLock)                   // 上锁
        if nprocs <= int32(cap(allp)) {   // 若预期 p 的数量 小于 allp 的容量(这里 allp 的容量大小是 程序执行至今 p 最多的时刻的 p 数量)
            allp = allp[:nprocs]          // 直接取切片(没有释放 多余 p 的空间)
        } else {                          // 若 历史最大 P 数量 小于 预期 P 数量 :
            nallp := make([]*p, nprocs)   // 按照预期 P 的数量创建空间
            copy(nallp, allp[:cap(allp)]) // 将 allp 直接复制到 新创空间中 (ps: 旧 P 已经初始化过)
            allp = nallp                  // allp 指针指向 新创建的空间
        }                                 
        unlock(&allpLock)                 // 解锁
    }
    // 遍历初始化需要新创建的 P
    for i := old; i < nprocs; i++ {       // 循环 需要创建的 P 的次数( 历史最大 P 数量 ～ 预期数量)
        pp := allp[i]                     
        if pp == nil {                    // 若 当前位置 nil，开辟空间创建 P 对象 (理论上应该都是 nil)
            pp = new(p)                   
        }
        pp.init(i)                        // 初始化新创建的 p, (使用序列 i 作为 p 的 ID)
        atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))  //  &allp[i] 指向 pp
    }

    // 调整 p 的工作状态
    _g_ := getg()   // 获取当前 Goroutine
    if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs {  
        // 若执行当前 G 的 M( 也可以说 线程; 个人还是倾向于 M 是 线程的指代/抽象) 存在 (m.p 是个 uintptr 默认值为 0),
        // 且其ID小于预期 P 的数量, 则继续使用当前的 P
        _g_.m.p.ptr().status = _Prunning            // 更改 当前 P 状态 为 Running
        _g_.m.p.ptr().mcache.prepareForSweep()      // 清空页面缓存
    } else {      // 当前 M 不存在 P 或者 P 的 id 已经大于当前 P 规定数量
        if _g_.m.p != 0 {                       // 当前 M 的 P 存在( 且序列已经超过预期 P 的个数 )
            if trace.enabled {                  // Trace 记录 并 停止 P 执行
                traceGoSched()
                traceProcStop(_g_.m.p.ptr())
            }
            _g_.m.p.ptr().m = 0     // 清楚 预释放 P 的 m指针 (不能让 停止的 p 还携带 m)
        }
        // M 的 P 不存在( 或者刚刚被清楚了 )
        _g_.m.p = 0              // 清空 当前 m 的 P 指针
        _g_.m.mcache = nil       // 清空当前 M 的 mcache (这个 mcache 实际上是从 P 中取到的)
        p := allp[0]             // 将 id = 0 的 p 交给 当前 M
        p.m = 0                  // 释放 这个 P 的 M 指针 ( id 为 0 的 P 不再为别的 M 服务了)
        p.status = _Pidle        // 重置 P 状态
        acquirep(p)              // 关联当前 P 和 M
        if trace.enabled {
            traceGoStart()       // 记录 Trace 事件
        }
    }

    for i := nprocs; i < old; i++ {  // 遍历多余的 P
        p := allp[i]
        p.destroy()        // 释放 P 的资源， 并将其转为 PDead
    }
}

func (pp *p) init(id int32) {
    pp.id = id                        // 赋予 id
    pp.status = _Pgcstop              // 初始化 status
    pp.sudogcache = pp.sudogbuf[:0]   // 初始化 sudog 队列的 cache 
    for i := range pp.deferpool {     // 初始化 defer 池
        pp.deferpool[i] = pp.deferpoolbuf[i][:0]
    }
    pp.wbBuf.reset()
    // 分配 cache 
    if pp.mcache == nil {      // 若当前 p 没有 cache空间
        if id == 0 {           // 且是第一个创建的
            if getg().m.mcache == nil {     // 守卫: 验证当前 M 的 cache 不为空
                throw("missing mcache?")
            }
            pp.mcache = getg().m.mcache     // 当前(最早创建的) M 的 cache (引导空间) 交给 最早创建的 P
        } else {
            pp.mcache = allocmcache()       // 分配新空间
        }
    }
    if raceenabled && pp.raceprocctx == 0 { ... }  // const raceenabled = false
}

func newproc(siz int32, fn *funcval) {             // siz 是参数长度， fn 是 go 执行的函数的引用指针
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)  // 从 fn 的地址增加一个指针的长度，从而获取第一个参数的地址
    gp := getg()                                   // 获得当前 G
    pc := getcallerpc()                            // 获得 pc 寄存器
    systemstack(func() {                           // 使用系统堆栈调用下面的函数
        newproc1(fn, argp, siz, gp, pc)            // 创建 G 
    })
}

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) {
    _g_ := getg()             // 获得当前 G
    if fn == nil {            // 守卫: 判断 fn 是否是 nil
        _g_.m.throwing = -1
        throw("go of nil func value")
    }
    acquirem()      // _g_ := getg(); _g_.m.locks++;  禁止当前 m 被抢占因为它可以在一个局部变量中保存 p
    siz := narg     
    siz = (siz + 7) &^ 7  // 8字节对齐。

    if siz >= _StackMin-4*sys.RegSize-sys.RegSize {    // 守卫： 穿参过大，超过内存控制范围
        throw("newproc: function arguments too large for new goroutine")
    }

    _p_ := _g_.m.p.ptr                    // 当前 P
    newg := gfget(_p_)                    // 通过 P 获得一个新 G
    if newg == nil {                      // 如果 新 G 是空的
        newg = malg(_StackMin)            // 创建一个拥有 _StackMin 大小的栈的 g     
        casgstatus(newg, _Gidle, _Gdead)  // 将新创建的 g 从 _Gidle 更新为 _Gdead 状态
        allgadd(newg)                     // 将 Gdead 状态的 g 添加到 allg，这样 GC 不会扫描未初始化的栈 
    }
    if newg.stack.hi == 0 {               // 守卫: 判断 newg 拥有的栈大小是否没有初始化
        throw("newproc1: newg missing stack")
    }
    if readgstatus(newg) != _Gdead {      // 守卫: 判断 newg 的状态 是否是 _Gdead
        throw("newproc1: new g is not Gdead")
    }
    // 计算运行空间大小，对齐
    totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // 计算程序需要的运行空间
    totalSize += -totalSize & (sys.SpAlign - 1)                  // 对齐到 spAlign

    sp := newg.stack.hi - totalSize                              // 确定 sp 入栈位置
    spArg := sp                                                  // 确定 参数 入栈位置
    if usesLR {
        *(*uintptr)(unsafe.Pointer(sp)) = 0
        prepGoExitFrame(sp)
        spArg += sys.MinFrameSize
    }
    if narg > 0 {  // 存在传参
        memmove(unsafe.Pointer(spArg), argp, uintptr(narg))  // 将传参的内容，复制到 新 G 的执行栈
        if writeBarrier.needed && !_g_.m.curg.gcscandone {   // 如果当前写屏蔽开启, 并且当前 G 的堆栈尚未被 GC 扫描
            f := findfunc(fn.fn)                             // 通过原方法的指针(开辟新的空间)构建方法对象(funcInfo)
            stkmap := (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))  // 将新创建的方法对象指针封装成栈映射对象(stackmap)
            if stkmap.nbit > 0 {                             // 若栈映射对象的索引大于 0
                bv := stackmapdata(stkmap, 0)                // 获取堆栈第0位的位向量
                bulkBarrierBitmap(spArg, spArg, uintptr(bv.n)*sys.PtrSize, 0, bv.bytedata)  // 重新将参数复制到 G 的执行栈
            }
        }
    }
    // 清理、创建并初始化的 g 的运行现场
    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))  // 清空 新创建的 G 的运行现场
    newg.sched.sp = sp                                // 初始化 运行现场的 sp 偏移量
    newg.stktopsp = sp                                // 初始化 sp 堆顶偏移量
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum    // 初始化 pc 偏移量
    newg.sched.g = guintptr(unsafe.Pointer(newg))     // 初始化 调度信息的 g (newg 获取指针 给 sched.g)
    gostartcallfn(&newg.sched, fn)                    // 根据 fn, 系统信息 调整 sched 的 sp, pc, ctxt
    // 初始化 newg 的状态
    newg.gopc = callerpc                              // 新 G 继承 当前 G 的 pc
    newg.ancestors = saveAncestors(callergp)          // 当前 G 封装成 []ancestorsInfo 赋值给 ancestors (祖先 g 列表)
    newg.startpc = fn.fn                              // 当前 G 的初始 PC 指向 fn的地址
    if _g_.m.curg != nil {                            // 若当前 M 运行的 G 不为空:
        newg.labels = _g_.m.curg.labels               // 新 G 继承 当前 M 运行的 G 的 标签
    }
    if isSystemGoroutine(newg, false) {               // 若 新创建的 g 是 System Goroutine 运行现场的系统g统计 + 1 
        atomic.Xadd(&sched.ngsys, +1)
    }
    casgstatus(newg, _Gdead, _Grunnable)              // 完成 newg 初始化， 转为 _Grunable 状态
    // 分配 goid 
    if _p_.goidcache == _p_.goidcacheend {
        _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
        _p_.goidcache -= _GoidCacheBatch - 1
        _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
    }
    newg.goid = int64(_p_.goidcache)
    _p_.goidcache++
    if raceenabled { ... }                       // const raceenabled = false 
    if trace.enabled {                           // 记录 Trace 事件
        traceGoCreate(newg, newg.startpc)
    }
    runqput(_p_, newg, true)                     // 将这里新创建的 g 放入 p 的本地队列或直接放入全局队列
    //  如果有空闲的 P、且 spinning 的 M 数量为 0，且主 goroutine 已经开始运行，则进行唤醒 p
    if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 && mainStarted {
        wakep()
    }
    releasem(_g_.m)  // 为 M 解锁 (回应 函数开头防止 M 被抢占上锁)
}