type hchan struct {
	// (一部抜粋)
	qcount   uint           // バッファ内にあるデータ数
	dataqsiz uint           // バッファ用のメモリの大きさ(何byteか)
	buf      unsafe.Pointer // バッファ内へのポインタ
	elemsize uint16
	closed   uint32
	elemtype *_type // チャネル型
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // 受信待ちしているGの連結リスト
	sendq    waitq  // 送信待ちしているGの連結リスト
}

type waitq struct {
	first *sudog
	last  *sudog
}

// sudog represents a g in a wait list, such as for sending/receiving
// on a channel.
type sudog struct {
	// (一部抜粋)
	g    *g  // Gそのもの
	next *sudog // 後要素へのポインタ(連結リストなので)
	prev *sudog // 前要素へのポインタ(連結リストなので)
	elem unsafe.Pointer // 送受信したい値
	c    *hchan // 送受信待ちをしている先のチャネル
}

TEXT main.main(SB) /path/to/main.go
// (略)
  main.go:4		0x105e1b1		e8ca55faff		CALL runtime.makechan(SB)		

func makechan(t *chantype, size int) *hchan

// entry point for c <- x from compiled code
func chansend1(c *hchan, elem unsafe.Pointer) {
	chansend(c, elem, true, getcallerpc())
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // (一部抜粋)
    if sg := c.recvq.dequeue(); sg != nil {
		// Found a waiting receiver. We pass the value we want to send
		// directly to the receiver, bypassing the channel buffer (if any).
		send(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true
	}
}

// send processes a send operation on an empty channel c.
// Channel c must be empty and locked.
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // (一部抜粋)
    if sg.elem != nil {
		sendDirect(c.elemtype, sg, ep) // 送信
	}
	gp := sg.g
    goready(gp, skip+1) // Gをrunableにする
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // (一部抜粋)
    if c.qcount < c.dataqsiz {
        // cのc.sendx番目のポインタをget
		qp := chanbuf(c, c.sendx)
		typedmemmove(c.elemtype, qp, ep) // bufにepを書き込み
		// sendxの値を更新
		c.sendx++
		if c.sendx == c.dataqsiz {
			c.sendx = 0
		}
		return true
	}
}

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // (一部抜粋)
    // Block on the channel. Some receiver will complete our operation for us.

	// sudogを作る
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.g = gp
	// sudogをチャネルのsendまちリストに入れる
    c.sendq.enqueue(mysg)
	// (goparkについては後述)
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
}

func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
	// (一部抜粋)
	mp := acquirem() // 今のmをgetする
	releasem(mp) // gのstackguard0をstackPreemptに書き換えて、プリエンプとしていいよってフラグにする
	mcall(park_m) //引数となっている関数を呼び出す
}

// park continuation on g0.
func park_m(gp *g) {
	// (一部抜粋)
	casgstatus(gp, _Grunning, _Gwaiting)
	dropg()
	schedule()
}

func chanrecv1(c *hchan, elem unsafe.Pointer) {
	chanrecv(c, elem, true)
}

func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
	_, received = chanrecv(c, elem, true)
	return
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // (一部抜粋)
    if sg := c.sendq.dequeue(); sg != nil {
		// Found a waiting sender. If buffer is size 0, receive value
		// directly from sender. Otherwise, receive from head of queue
		// and add sender's value to the tail of the queue (both map to
		// the same buffer slot because the queue is full).
		recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true, true
	}
}

func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // (一部抜粋)
    // bufがないなら直接
	if c.dataqsiz == 0 {
		if ep != nil {
			// copy data from sender
			recvDirect(c.elemtype, sg, ep)
		}
	} else {
        // Queue is full. Take the item at the
		// head of the queue. Make the sender enqueue
		// its item at the tail of the queue. Since the
		// queue is full, those are both the same slot.
        qp := chanbuf(c, c.recvx)
        // copy data from queue to receiver
		if ep != nil {
			typedmemmove(c.elemtype, ep, qp)
		}
		// copy data from sender to queue
		typedmemmove(c.elemtype, qp, sg.elem)
		c.recvx++
		if c.recvx == c.dataqsiz {
			c.recvx = 0
		}
		c.sendx = c.recvx
	}
	gp := sg.g
	goready(gp, skip+1)
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // (一部抜粋)
    if c.qcount > 0 {
		// Receive directly from queue
		qp := chanbuf(c, c.recvx)
		if ep != nil {
			typedmemmove(c.elemtype, ep, qp) // epにバッファの中身を書き込み
		}
		// recvxの値を更新
		c.recvx++
		if c.recvx == c.dataqsiz {
			c.recvx = 0
		}
	}
}

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // (一部抜粋)
    // no sender available: block on this channel.

	// sudogを作って設定
	gp := getg()
	mysg := acquireSudog()
    mysg.elem = ep
    mysg.g = gp

	// 作ったsudogをrecvqに追加
    c.recvq.enqueue(mysg)

	// (goparkの内容については前述の通り)
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
}