golang select实现原理

select{} -> runtime.block() -> gopark()
// gc/select/walkselectcases
// optimization: zero-case select
if n == 0 {
  return []*Node{mkcall("block", nil, nil)}// 这里编译器优化为调用runtime.block
}

// runtime.block. 最终调用还是 gopark() 阻塞goroutine
func block() {
	gopark(nil, nil, waitReasonSelectNoCases, traceEvGoStop, 1) // forever
}

select{								if v<-foo {
    case <-foo:	    -> 		            ...
}									}

select{								if v<-foo {
case <-foo:			-> 		            ....
default:							} else {
}									}

type runtimeSelect struct {
	dir selectDir      // 表示case的类型，读chan、写chan、default
	typ unsafe.Pointer // channel type (not used here)
	ch  *hchan         // channel
	val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)  case读或写的数据指针
}

type scase struct {
	c    *hchan         // chan
	elem unsafe.Pointer // data element
}

func reflect_rselect(cases []runtimeSelect) (int, bool) {
	if len(cases) == 0 {
		block()
	}
	sel := make([]scase, len(cases))
	orig := make([]int, len(cases))
	nsends, nrecvs := 0, 0
	dflt := -1
    // 将select中的case转化为scase
	for i, rc := range cases {
		var j int
		switch rc.dir {
		case selectDefault:
			dflt = i
			continue
		case selectSend:
			j = nsends
			nsends++
		case selectRecv:
			nrecvs++
			j = len(cases) - nrecvs
		}
// 这儿的处理方式是，sel数组中前面是send的case，后面是recv的case。
		sel[j] = scase{c: rc.ch, elem: rc.val}
		orig[j] = i
	}

	// 只有default的case，直接就选择default了。
	if nsends+nrecvs == 0 {
		return dflt, false
	}

    ...

//调用selectgo函数，选择对应的case执行
	chosen, recvOK := selectgo(&sel[0], &order[0], pc0, nsends, nrecvs, dflt == -1)
// 根据selectgo返回值选择case 
	if chosen < 0 {
		chosen = dflt
	} else {
		chosen = orig[chosen]
	}
	return chosen, recvOK
}

func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool) {
    cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
    order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
 
    scases := cas1[:ncases:ncases]
    pollorder := order1[:ncases:ncases]
    lockorder := order1[ncases:][:ncases:ncases]
 
    norder := 0
	for i := range scases {
		cas := &scases[i]

		// Omit cases without channels from the poll and lock orders.
		if cas.c == nil {
			cas.elem = nil // allow GC
			continue
		}

		j := fastrandn(uint32(norder + 1))
		pollorder[norder] = pollorder[j]
		pollorder[j] = uint16(i)
		norder++
	}
	pollorder = pollorder[:norder]
	lockorder = lockorder[:norder] 
    // ...  代码较长不粘贴了，没有什么特殊的就是实现一个堆排序
    // 根据channel的内存地址使用堆排序的方式进行排序
    // 为什么要排序呢，因为case中可能存在操作相同的chan，如果不排序，那么
    // 就可能出现对同一个chan上锁，导致卡死。排序后如果是相同的chan就不
    // 加锁了
    // ...  代码较长不粘贴了 . . .
    
    // lock all the channels involved in the select
    sellock(scases, lockorder)
}

// pass 1 - look for something already waiting
// 看看是否有准备就绪的chan
for _, casei := range pollorder {
		casi = int(casei)
		cas = &scases[casi]
		c = cas.c
        // 是接受数据的case
		if casi >= nsends {
        // chan有等待的goroutine 
			sg = c.sendq.dequeue()
			if sg != nil {
				goto recv
			}
        // chan的缓冲区不为空
			if c.qcount > 0 {
				goto bufrecv
			}
        // chan已经关闭
			if c.closed != 0 {
				goto rclose
			}
        // 是发送数据的case
		} else {
            // chan已经关闭
			if c.closed != 0 {
				goto sclose
			}
            // chan的recvq上有等待的goroutine 
			sg = c.recvq.dequeue()
			if sg != nil {
				goto send
			}
            // 往chan的缓冲区写数据
			if c.qcount < c.dataqsiz {
				goto bufsend
			}
		}
	}
    // 如果select语句中有default分支
	if !block {
		selunlock(scases, lockorder)
		casi = -1
		goto retc
	}

// pass 2 - enqueue on all chans
// 没有准备好的chan，就将G加入到所有的chan中sendq或者recvq中，并挂起等待
    var(
        gp     *g
        nextp  **sudog
    )
    // 获取当前的g
	gp = getg()
    // 下面会给根据每个case创建一个sudog，加入到当前g的waiting列表
	nextp = &gp.waiting
	for _, casei := range lockorder {
		casi = int(casei)
		cas = &scases[casi]
		c = cas.c
        // 创建一个sudog，管理当前的g
        // 这块的处理和chan阻塞的处理方式一样，也是要保存自己当前的g
        // 目的都是后面需要将当前g挂起
		sg := acquireSudog()
		sg.g = gp
		sg.isSelect = true
		sg.elem = cas.elem
		sg.releasetime = 0
		if t0 != 0 {
			sg.releasetime = -1
		}
		sg.c = c
		// sudog结构体都会被串成链表附着在当前 goroutine 上
		*nextp = sg
		nextp = &sg.waitlink

		if casi < nsends {
			c.sendq.enqueue(sg)
		} else {
			c.recvq.enqueue(sg)
		}
	}

	// 调用 gopark 函数挂起当前的 goroutine 等待调度器的唤醒
    // 我们创建的sudog加入到各个chan中，如果有一个sudog被唤醒，将会执行
    // gopark后面的逻辑      
	gp.param = nil
	atomic.Store8(&gp.parkingOnChan, 1)
	gopark(selparkcommit, nil, waitReasonSelect, traceEvGoBlockSelect, 1)

 gp.selectDone = 0
    // 这儿的gp的param应该是gopark之后被唤醒，导致被唤醒的那个sudog
	sg = (*sudog)(gp.param)
	gp.param = nil
    casi := -1
	cas := nil
	caseSuccess := false
	sglist := gp.waiting
	// 被唤醒后，清除我们之前生成的sudog的一些数据.
	for sg1 := gp.waiting; sg1 != nil; sg1 = sg1.waitlink {
		sg1.isSelect = false
		sg1.elem = nil
		sg1.c = nil
	}
	gp.waiting = nil
// 遍历case
for _, casei := range lockorder {
		k = &scases[casei]
        // 找到被唤醒的sudog
		if sg == sglist {
			// sg has already been dequeued by the G that woke us up.
            // 获取到case里面的chan
			casi = int(casei)
			cas = k
			caseSuccess = sglist.success
			if sglist.releasetime > 0 {
				caseReleaseTime = sglist.releasetime
			}
        // 不是唤醒的sudog，我们也需要将它从其他case的chan里面的队列拿出来
        // 因为被唤醒的sudog已经被它对应的chan执行出队的操作，不再需要
		} else {
			c = k.c
			if int(casei) < nsends {
				c.sendq.dequeueSudoG(sglist)
			} else {
				c.recvq.dequeueSudoG(sglist)
			}
		}
        // 持续寻找被唤醒的那个sudog，类十余一个迭代器
		sgnext = sglist.waitlink
		sglist.waitlink = nil
        // 我们已经不再需要之前创建的sudog了，清理掉
		releaseSudog(sglist)
		sglist = sgnext
	}
    // 就是这个case的chan有数据被唤醒的，我们可以操作这个chan了
	c := cas.c

    // 这儿的意思是，如果我们的sudog被唤醒的原因是因为chan被关闭了而被唤醒的
    // 那么就走sclose逻辑，sclose里面会panic。因为不能往一个被关闭的chan
    // 里面send数据，但是可以往关闭的chan里面读取数据
	if casi < nsends {
		if !caseSuccess {
			goto sclose
		}
	} else {
		recvOK = caseSuccess
	}
    // 解锁所有的case
	selunlock(scases, lockorder)
	goto retc

    // 这个recv是chan的recv函数，其实就是从chan获取数据
	recv(c, sg, cas.elem, func() { selunlock(scases, lockorder) }, 2)
	recvOK = true
	goto retc

//  向chan的缓冲区获取数据
    recvOK = true
    // chan的chanbuf函数，获取chan的buf指针
	qp = chanbuf(c, c.recvx)
    // move数据到case的变量
	if cas.elem != nil {
		typedmemmove(c.elemtype, cas.elem, qp)
	}
    // 实现chan从缓冲区读数据的操作
	typedmemclr(c.elemtype, qp)
	c.recvx++
	if c.recvx == c.dataqsiz {
		c.recvx = 0
	}
	c.qcount--
	selunlock(scases, lockorder)
	goto retc

   selunlock(scases, lockorder)
	recvOK = false
    // 实现了从关闭的chan读取数据。
	if cas.elem != nil {
		typedmemclr(c.elemtype, cas.elem)
	}
	goto retc

  // send on closed channel
	selunlock(scases, lockorder)
    // 王close的chan写数据是panic的
	panic(plainError("send on closed channel"))

// chan的send函数，往chan发送数据
send(c, sg, cas.elem, func() { selunlock(scases, lockorder) }, 2)
goto retc

 // move case的数据到chan中。
    typedmemmove(c.elemtype, chanbuf(c, c.sendx), cas.elem)
    // 下面间接实现了chan的一些send操作
	c.sendx++
	if c.sendx == c.dataqsiz {
		c.sendx = 0
	}
	c.qcount++
	selunlock(scases, lockorder)
	goto retc