1
import (
2
  mu sync.Mutex
3
  mu2 sync.RWMutex
4
  wp sync.WaitGroup
5

6
)
7
func main(){
8
  wp.Add(1)
9
  go func(){
10
    defer wp.Done()
11
    log.Println("1")
12
  }
13

14
  mu.Lock() // 互斥锁
15
  mu2.Lock() // 写锁
16
  mu2.RLock() // 读锁
17

18
  mu.UnLock() // 互斥锁
19
  mu2.UnLock() // 写锁
20
  mu2.RUnLock() // 读锁
21

22
  wp.Wait()
23

24
}

1
type hchan struct {
2
    qcount   uint           // 队列中现存的元素总数
3
    dataqsiz uint           // 环形队列的容量（即缓冲区大小）
4
    buf      unsafe.Pointer // 指向底层连续内存数组的指针（存放数据的地方）
5
    elemsize uint16         // 元素的大小（字节数，比如 int64 就是 8 字节）
6
    closed   uint32         // 标识通道是否关闭（0: 打开, 1: 关闭）
7
    elemtype *_type        // 元素类型（用于反射和类型安全检查）
8

9
    sendx    uint           // 缓冲区发送索引（数组下标，下次写数据的位置）
10
    recvx    uint           // 缓冲区接收索引（数组下标，下次读数据的位置）
11

12
    recvq    waitq          // 阻塞在这里等待【接收】数据的协程链表（sudog 链表）
13
    sendq    waitq          // 阻塞在这里等待【发送】数据的协程链表（sudog 链表）
14

15
    lock     mutex          // 互斥锁！保护上面所有字段的并发安全
16
}
17

18
func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
19
    // 1. 如果 channel 是空的（nil）
20
    if c == nil {
21
        if !block {
22
            return false
23
        }
24
        // 如果是阻塞发送，直接让当前协程永久躺倒（挂起）
25
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoBlockSend, 2)
26
        throw("unreachable")
27
    }
28

29
    // 2. 核心操作开始：第一步永远是【加锁】
30
    lock(&c.lock)
31

32
    // 3. 如果 channel 已经关闭，加锁状态下抛出 panic
33
    if c.closed != 0 {
34
        unlock(&c.lock)
35
        panic(plainError("send on closed channel"))
36
    }
37

38
    // 4. 【情况一：有现成的接收者在等数据】（无锁零拷贝优化）
39
    // 从 recvq 队列里弹出一个正在死等数据的协程（sudog）
40
    if sg := c.recvq.dequeue(); sg != nil {
41
        // 找到了等待的接收者！直接把数据拷贝到它的栈内存里，并唤醒它
42
        // 这个过程不需要经过 c.buf 缓冲区中转
43
        send(c, sg, ep, func() { unlock(&c.lock) }, 3)
44
        return true
45
    }
46

47
    // 5. 【情况二：缓冲区还没满】
48
    if c.qcount < c.dataqsiz {
49
        // 还有空位，把数据放进环形数组 c.buf
50
        qp := chanbuf(c, c.sendx)          // 找到当前发送索引对应的内存地址
51
        typedmemmove(c.elemtype, qp, ep)   // 将数据 ep 拷贝到 qp 指向的缓冲区
52
        c.sendx++                          // 发送下标往后移
53
        if c.sendx == c.dataqsiz {         // 环形队列走到末尾，折返回头部
54
            c.sendx = 0
55
        }
56
        c.qcount++                         // 队列元素计数 +1
57

58
        unlock(&c.lock)                    // 【解锁】，发送成功返回
59
        return true
60
    }
61

62
    // 如果是异步非阻塞发送（例如 select 里的 send），缓冲区满了就直接解锁返回 false
63
    if !block {
64
        unlock(&c.lock)
65
        return false
66
    }
67

68
    // 6. 【情况三：缓冲区满了，且无人在等数据】（协程挂起）
69
    gp := getg()                       // 获取当前的协程对象（Goroutine）
70
    mysg := acquireSudog()             // 从对象池里打包一个临时的登记节点（sudog）
71
    mysg.elem = ep                     // 把你要发送的数据地址挂在节点上
72
    mysg.g = gp                        // 节点绑定当前协程
73
    mysg.c = c                         // 节点绑定当前 channel
74

75
    c.sendq.enqueue(mysg)              // 把这个节点推进 channel 的发送等待链表
76

77
    // 【关键动作】：调用 gopark 释放锁，并将当前协程转入等待状态
78
    // 从这一刻起，当前协程不占用 CPU，直到别人读取数据将其唤醒
79
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
80

81
    // ———————— 被唤醒后的分割线 ————————
82
    // 当另一个协程读取了数据，它会调用 goready() 重新激活这个协程，代码从这里继续往下走
83

84
    releaseSudog(mysg)                 // 释放临时登记节点
85
    return true
86
}

1
// 运行时的底层判定逻辑（伪代码）
2
 func checkdead() { run := sched.runnablecnt // 当前可运行的协程数量
3
   if run > 0 { return // 还有人能跑，不算死锁
4
   } // 关键账目对比： // nmidlelocked 是被锁住的线程，sysmon 是系统监控 // 除去这些后，看看全天下总共还有多少个活着的协程（包括睡着的）
5
   aliveCount := runtime.gcount() if aliveCount == 0 { // 如果连睡着的协程都没有，说明程序是正常运行完自然退出的
6
   return } // 【致命判定】：如果活着的协程数量 > 0（比如 main 还在），但可运行的数量为 0 // 这意味着：这群活着的协程全部在睡觉，且断绝了所有被唤醒的可能！
7
   panic("fatal error: all goroutines are asleep - deadlock!")
8
 }

1
ch := make(chan int)

1
select{
2
case data <- ch:
3
      printlf("发送成功")
4
default:
5
      println("干一些别的事情")
6
}