chan 的底层实现是怎么样的？

chan 是 Go 语言中的一个关键字，用于实现并发通信。chan 可以用于在不同的 goroutine 之间传递数据，实现数据的同步和异步传输。

在底层实现上，chan 是通过一个结构体来表示的，这个结构体包含了一个指向数据的指针和两个指向信道的指针。其中，一个指针用于发送数据，另一个指针用于接收数据。

下面是 chan 的底层实现代码：

type hchan struct {
    qcount   uint           // 当前队列中的元素数量
    dataqsiz uint           // 队列的容量
    buf      unsafe.Pointer // 指向队列的指针
    elemsize uint16         // 元素的大小
    closed   uint32         // 是否关闭
    elemtype *_type         // 元素的类型
    sendx    uint           // 发送的位置
    recvx    uint           // 接收的位置
    recvq    waitq          // 接收等待队列
    sendq    waitq          // 发送等待队列
    lock     mutex          // 锁
}

chan 的发送和接收操作的底现

当我们向 chan 发送数据时，会先检查 chan 是否已经关闭。如果 chan 已经关闭，那么发送操作会直接返回一个 panic。否则，会将数据复制到队列中，并更新发送位置。

下面是 chan 发送操作的底层实现代码：

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    // 检查 chan 是否已经关闭
    if c.closed != 0 {
        panic("send on closed channel")
    }
    // 计算发送位置
    i := c.sendx
    // 计算队列中的元素数量
    if c.qcount < c.dataqsiz {
        c.qcount++
    } else {
        // 如果队列已满，需要扩容
        grow(c)
    }
    // 更新发送位置
    c.sendx++
    // 将数据复制到队列中
    qput(c, i, ep)
    return true
}

当我们从 chan 接收数据时，也会先检查 chan 是否已经关闭。如果 chan 已经关闭并且队列中没有数据，那么接收操作会直接返回一个零值。否则，会从队列中取出数据，并更新接收位置。

下面是 chan 接收操作的底层实现代码：

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 检查 chan 是否已经关闭
    if c.closed != 0 && c.qcount == 0 {
        return false, false
    }
    // 计算接收位置
    i := c.recvx
    // 如果队列中没有数据，需要阻塞等待
    for c.qcount <= 0 {
        if !block {
            return false, false
        }
        gopark(chanparkcommit, unsafe.Pointer(c), "chan receive", traceEvGoBlockRecv, 1)
    }
    // 从队列中取出数据
    qget(c, i, ep)
    // 更新接收位置
    c.recvx++
    // 更新队列中的元素数量
    c.qcount--
    return true, true
}

chan 是如何实现多个 gorouting 并发安全访问的？

如上 hchan 结构中的 recvq 和 sendq 分别表示接收等待队列和发送等待队列，它们的定义如下：

type waitq struct {
    first *sudog // 等待队列的第一个元素
    last  *sudog // 等待队列的最后一个元素
}

sudog 表示等待队列中的一个元素，它的定义如下：

type sudog struct {
    // 等待的 goroutine
    g *g
    // 是否是 select 操作
    isSelect bool
    // 等待队列中的下一个元素
    next *sudog
    // 等待队列中的上一个元素
    prev *sudog
    // 等待的元素
    elem unsafe.Pointer
    // 获取锁的时间
    acquiretime int64
    // 保留字段
    release2 uint32
    // 等待的 ticket
    ticket uint32
    // 父 sudog
    parent *sudog
    // 等待链表
    waitlink *sudog
    // 等待链表的尾部
    waittail *sudog
    // 关联的 chan
    c *hchan
    // 唤醒时间
    releasetime int64
}

当 chan 的队列已满或为空时，当前 goroutine 会被加入到发送等待队列或接收等待队列中，并释放锁。当另一个 goroutine 从 chan 中取出数据或向 chan 发送数据时，它会重新获取锁，并从等待队列中取出一个 goroutine，将其唤醒。这样，多个 goroutine 就可以通过等待队列来实现并发访问 chan。

sudog 是 Go 中非常重要的数据结构，因为 g 与同步对象关系是多对多的。

一个 g 可以出现在许多等待队列上，因此一个 g 可能有很多sudog：在 select 操作中，一个 goroutine 可以等待多个 chan 中的任意一个就绪， sudog 中的 isSelect 字段被用来标记它是否是 select 操作。当一个 chan 就绪时，它会唤醒对应的 sudog，并将其从等待队列中移除。如果一个 sudog 是 select 操作，它会在唤醒后返回一个特殊的值，表示哪个 chan 就绪了

多个 g 可能正在等待同一个同步对象，因此一个对象可能有许多 sudog：chan 在不同的 gorouting 中传递等待

完整的发送和接受方法实现如下：

func chansend(c *hchan, ep unsafe.Pointer, block bool) bool {
    // 获取 chan 的锁
    lock(&c.lock)
    // 检查 chan 是否已经关闭
    if c.closed != 0 {
        unlock(&c.lock)
        panic("send on closed channel")
    }
    // 计算发送位置
    i := c.sendx
    // 计算队列中的元素数量
    if c.qcount < c.dataqsiz {
        c.qcount++
    } else {
        // 如果队列已满，需要将当前 goroutine 加入到发送等待队列中
        g := getg()
        gp := g.m.curg
        if !block {
            unlock(&c.lock)
            return false
        }
        // 创建一个 sudog，表示当前 goroutine 等待发送
        sg := acquireSudog()
        sg.releasetime = 0
        sg.acquiretime = 0
        sg.g = gp
        sg.elem = ep
        sg.c = c
        // 将 sudog 加入到发送等待队列中
        c.sendq.enqueue(sg)
        // 释放锁，并将当前 goroutine 阻塞
        unlock(&c.lock)
        park_m(gp, waitReasonChanSend, traceEvGoBlockSend, 1)
        // 当 goroutine 被唤醒时，重新获取锁
        lock(&c.lock)
        // 检查 chan 是否已经关闭
        if c.closed != 0 {
            unlock(&c.lock)
            panic("send on closed channel")
        }
        // 从发送等待队列中取出 sudog
        sg = c.sendq.dequeue()
        if sg == nil {
            throw("chan send inconsistency")
        }
        // 将数据复制到队列中
        qput(c, i, ep)
    }
    // 更新发送位置
    c.sendx++
    // 释放锁
    unlock(&c.lock)
    return true
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // 获取 chan 的锁
    lock(&c.lock)
    // 检查 chan 是否已经关闭
    if c.closed != 0 && c.qcount == 0 {
        unlock(&c.lock)
        return false, false
    }
    // 计算接收位置
    i := c.recvx
    // 如果队列中没有数据，需要将当前 goroutine 加入到接收等待队列中
    if c.qcount <= 0 {
        g := getg()
        gp := g.m.curg
        if !block {
            unlock(&c.lock)
            return false, false
        }
        // 创建一个 sudog，表示当前 goroutine 等待接收
        sg := acquireSudog()
        sg.releasetime = 0
        sg.acquiretime = 0
        sg.g = gp
        sg.elem = ep
        sg.c = c
        // 将 sudog 加入到接收等待队列中
        c.recvq.enqueue(sg)
        // 释放锁，并将当前 goroutine 阻塞
        unlock(&c.lock)
        park_m(gp, waitReasonChanReceive, traceEvGoBlockRecv, 1)
        // 当 goroutine 被唤醒时，重新获取锁
        lock(&c.lock)
        // 检查 chan 是否已经关闭
        if c.closed != 0 && c.qcount == 0 {
            unlock(&c.lock)
            return false, false
        }
        // 从接收等待队列中取出 sudog
        sg = c.recvq.dequeue()
        if sg == nil {
            throw("chan receive inconsistency")
        }
        // 从队列中取出数据
        qget(c, i, ep)
    } else {
        // 从队列中取出数据
        qget(c, i, ep)
    }
    // 更新接收位置
    c.recvx++
    // 更新队列中的元素数量
    c.qcount--
    // 释放锁
    unlock(&c.lock)
    return true, true
}