Golang的select怎么使用

本文小编为大家详细介绍“golang的select怎么使用”，内容详细，步骤清晰，细节处理妥当，希望这篇“Golang的select怎么使用”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

背景

golang 中主推 channel 通信。单个 channel 的通信可以通过一个goroutine往 channel 发数据，另外一个从channel取数据进行。这是阻塞的，因为要想顺利执行完这个步骤，需要 channel 准备好才行，准备好的条件如下:

发送

• 缓存有空间(如果是有缓存的 channel)

• 有等待接收的 goroutine

接收

• 缓存有数据(如果是有缓存的 channel)

• 有等待发送的 goroutine

对channel实际使用中还有如下两个需求，这个时候就需要select了。

• 同时监听多个channel

• 在没有channel准备好的时候，也可以往下执行。

select 流程

空select。作用是阻塞当前goroutine。不要用for{}来阻塞goroutine，因为会占用cpu。而select{}不会，因为当前goroutine不会再被调度。

 if len(cases) == 0 {         block() }

配置好poll的顺序。由于是同时监听多个channel的发送或者接收，所以需要按照一定的顺序查看哪个channel准备好了。如果每次采用select中的顺序查看channel是否准备好了，那么只要在前面的channel准备好的足够快，那么会造成后面的channel即使准备好了，也永远不会被执行。打乱顺序的逻辑如下，采用了洗牌算法\color{red}{洗牌算法}洗牌算法，注意此过程中会过滤掉channel为nil的case。\color{red}{注意此过程中会过滤掉 channel 为 nil 的 case。}注意此过程中会过滤掉channel为nil的case。

 // generate permuted order 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++ }

配置好lock的顺序。由于可能会修改channel中的数据，所以在打算往channel中发送数据或者从channel接收数据的时候，需要锁住 channel。而一个channel可能被多个select监听，如果两个select对两个channel A和B，分别按照顺序A, B和B,A上锁，是可能会造成死锁的，导致两个select都执行不下去。

所以select中锁住channel的顺序至关重要，解决方案是按照channel的地址的顺序锁住channel。因为在两个select中channel有交集的时候，都是按照交集中channel的地址顺序锁channel。

实际排序代码如下，采用堆排序算法\color{red}{堆排序算法}堆排序算法按照channel的地址从小到大对channel进行排序。

 // sort the cases by Hchan address to get the locking order. // simple heap sort, to guarantee n log n time and constant stack footprint. for i := range lockorder {         j := i         // Start with the pollorder to permute cases on the same channel.         c := scases[pollorder[i]].c         for j > 0 && scases[lockorder[(j-1)/2]].c.sorTKEy() < c.sortkey() {                 k := (j - 1) / 2                 lockorder[j] = lockorder[k]                 j = k         }         lockorder[j] = pollorder[i] } for i := len(lockorder) - 1; i >= 0; i-- {         o := lockorder[i]         c := scases[o].c         lockorder[i] = lockorder[0]         j := 0         for {                 k := j*2 + 1                 if k >= i {                         break                 }                 if k+1 < i && scases[lockorder[k]].c.sortkey() < scases[lockorder[k+1]].c.sortkey() {                         k++                 }                 if c.sortkey() < scases[lockorder[k]].c.sortkey() {                         lockorder[j] = lockorder[k]                         j = k                         continue                 }                 break         }         lockorder[j] = o }

锁住select中的所有channel。要查看channel中的数据了。

 // lock all the channels involved in the select sellock(scases, lockorder)

第一轮查看是否已有准备好的channel。如果有直接发送数据到channel或者从channel接收数据。注意select的channel切片中，前面部分是从channel接收数据的case，后半部分是往channel发送数据的case。

按照pollorder顺序查看是否有channel准备好了。

 for _, casei := range pollorder {         casi = int(casei)         cas = &scases[casi]         c = cas.c         if casi >= nsends {                 sg = c.sendq.dequeue()                 if sg != nil {                         goto recv                 }                 if c.qcount > 0 {                         goto bufrecv                 }                 if c.closed != 0 {                         goto rclose                 }         } else {                 if raceenabled {                         racereadpc(c.raceaddr(), casePC(casi), chansendpc)                 }                 if c.closed != 0 {                         goto sclose                 }                 sg = c.recvq.dequeue()                 if sg != nil {                         goto send                 }                 if c.qcount < c.dataqsiz {                         goto bufsend                 }         } }

直接执行default分支

 if !block {         selunlock(scases, lockorder)         casi = -1         goto retc }

第二轮遍历channel。创建sudog把当前goroutine放到每个channel的等待列表中去，等待channel准备好时被唤醒。

 // pass 2 - enqueue on all chans gp = getg() if gp.waiting != nil {         throw("gp.waiting != nil") } nextp = &gp.waiting for _, casei := range lockorder {         casi = int(casei)         cas = &scases[casi]         c = cas.c         sg := acquireSudog()         sg.g = gp         sg.isSelect = true         // No stack splits between assigning elem and enqueuing         // sg on gp.waiting where copystack can find it.         sg.elem = cas.elem         sg.releasetime = 0         if t0 != 0 {                 sg.releasetime = -1         }         sg.c = c         // Construct waiting list in lock order.         *nextp = sg         nextp = &sg.waitlink         if casi < nsends {                 c.sendq.enqueue(sg)         } else {                 c.recvq.enqueue(sg)         } }

等待被唤醒。其中gopark的时候会释放对所有channel占用的锁。

 // wait for someone to wake us up gp.param = nil // Signal to anyone trying to shrink our stack that we're about // to park on a channel. The window between when this G's status // changes and when we set gp.activeStackChans is not safe for // stack shrinking. atomic.Store8(&gp.parkingOnChan, 1) gopark(selparkcommit, nil, waitReasonSelect, traceEvGoBlockSelect, 1) gp.activeStackChans = false

被唤醒

• 锁住所有channel

• 清理当前goroutine的等待sudog

• 找到是被哪个channel唤醒的，并清理每个channel上当前的goroutine对应的sudog

 sellock(scases, lockorder) gp.selectDone = 0 sg = (*sudog)(gp.param) gp.param = nil // pass 3 - dequeue from unsuccessful chans // otherwise they stack up on quiet channels // record the successful case, if any. // We singly-linked up the SudoGs in lock order. casi = -1 cas = nil caseSuccess = false sglist = gp.waiting // Clear all elem before unlinking from gp.waiting. for sg1 := gp.waiting; sg1 != nil; sg1 = sg1.waitlink {         sg1.isSelect = false         sg1.elem = nil         sg1.c = nil } gp.waiting = nil for _, casei := range lockorder {         k = &scases[casei]         if sg == sglist {                 // sg has already been dequeued by the G that woke us up.                 casi = int(casei)                 cas = k                 caseSuccess = sglist.success                 if sglist.releasetime > 0 {                         caseReleaseTime = sglist.releasetime                 }         } else {                 c = k.c                 if int(casei) < nsends {                         c.sendq.dequeueSudoG(sglist)                 } else {                         c.recvq.dequeueSudoG(sglist)                 }         }         sgnext = sglist.waitlink         sglist.waitlink = nil         releaseSudog(sglist)         sglist = sgnext }

读到这里，这篇“Golang的select怎么使用”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注编程网GO频道。