Question

同步和异步通道的区别在于是否创建缓冲区。

// chan.go

type hchan struct {
	qcount   uint           // total data in the queue
	dataqsiz uint           // size of the circular queue
	buf      unsafe.Pointer // points to an array of dataqsiz elements
    
	elemsize uint16
	elemtype *_type // element type
    
	closed   uint32
    
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // list of recv waiters
	sendq    waitq  // list of send waiters

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex
}

根据是否包含指针，来选择内存分配模式。

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

    // 元素长度不能超过 64 KB。
	if elem.size >= 1<<16 {
		throw("makechan: invalid channel element type")
	}

    // 缓冲区内存限制。（元素大小 * 数量）
	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:
        // 队列或元素长度为零，不分配缓冲区。（hchanSize = sizeof hchan）
		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)
    
	lockInit(&c.lock, lockRankHchan)
	return c
}