Golang的select怎么使用

本文小編為大家詳細(xì)介紹“Golang的select怎么使用”，內(nèi)容詳細(xì)，步驟清晰，細(xì)節(jié)處理妥當(dāng)，希望這篇“Golang的select怎么使用”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學(xué)習(xí)新知識吧。

背景

golang 中主推 channel 通信。單個(gè) channel 的通信可以通過一個(gè)goroutine往 channel 發(fā)數(shù)據(jù)，另外一個(gè)從channel取數(shù)據(jù)進(jìn)行。這是阻塞的，因?yàn)橐腠樌麍?zhí)行完這個(gè)步驟，需要 channel 準(zhǔn)備好才行，準(zhǔn)備好的條件如下:

1.發(fā)送

• 緩存有空間(如果是有緩存的 channel)

• 有等待接收的 goroutine

2.接收

• 緩存有數(shù)據(jù)(如果是有緩存的 channel)

• 有等待發(fā)送的 goroutine

對channel實(shí)際使用中還有如下兩個(gè)需求，這個(gè)時(shí)候就需要select了。

• 同時(shí)監(jiān)聽多個(gè)channel

• 在沒有channel準(zhǔn)備好的時(shí)候，也可以往下執(zhí)行。

select 流程

1.空select。作用是阻塞當(dāng)前goroutine。不要用for{}來阻塞goroutine，因?yàn)闀加胏pu。而select{}不會，因?yàn)楫?dāng)前goroutine不會再被調(diào)度。

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

2.配置好poll的順序。由于是同時(shí)監(jiān)聽多個(gè)channel的發(fā)送或者接收，所以需要按照一定的順序查看哪個(gè)channel準(zhǔn)備好了。如果每次采用select中的順序查看channel是否準(zhǔn)備好了，那么只要在前面的channel準(zhǔn)備好的足夠快，那么會造成后面的channel即使準(zhǔn)備好了，也永遠(yuǎn)不會被執(zhí)行。打亂順序的邏輯如下，采用了洗牌算法\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++
 }

3.配置好lock的順序。由于可能會修改channel中的數(shù)據(jù)，所以在打算往channel中發(fā)送數(shù)據(jù)或者從channel接收數(shù)據(jù)的時(shí)候，需要鎖住 channel。而一個(gè)channel可能被多個(gè)select監(jiān)聽，如果兩個(gè)select對兩個(gè)channel A和B，分別按照順序A, B和B,A上鎖，是可能會造成死鎖的，導(dǎo)致兩個(gè)select都執(zhí)行不下去。

所以select中鎖住channel的順序至關(guān)重要，解決方案是按照channel的地址的順序鎖住channel。因?yàn)樵趦蓚€(gè)select中channel有交集的時(shí)候，都是按照交集中channel的地址順序鎖channel。

實(shí)際排序代碼如下，采用堆排序算法\color{red}{堆排序算法}堆排序算法按照channel的地址從小到大對channel進(jìn)行排序。

 // 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
 }

4.鎖住select中的所有channel。要查看channel中的數(shù)據(jù)了。

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

5.第一輪查看是否已有準(zhǔn)備好的channel。如果有直接發(fā)送數(shù)據(jù)到channel或者從channel接收數(shù)據(jù)。注意select的channel切片中，前面部分是從channel接收數(shù)據(jù)的case，后半部分是往channel發(fā)送數(shù)據(jù)的case。

按照pollorder順序查看是否有channel準(zhǔn)備好了。

 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
                 }
         }
 }

6.直接執(zhí)行default分支

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

7.第二輪遍歷channel。創(chuàng)建sudog把當(dāng)前goroutine放到每個(gè)channel的等待列表中去，等待channel準(zhǔn)備好時(shí)被喚醒。

 // 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)
         }
 }

8.等待被喚醒。其中gopark的時(shí)候會釋放對所有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

9.被喚醒

• 鎖住所有channel

• 清理當(dāng)前goroutine的等待sudog

• 找到是被哪個(gè)channel喚醒的，并清理每個(gè)channel上當(dāng)前的goroutine對應(yīng)的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怎么使用”文章已經(jīng)介紹完畢，想要掌握這篇文章的知識點(diǎn)還需要大家自己動手實(shí)踐使用過才能領(lǐng)會，如果想了解更多相關(guān)內(nèi)容的文章，歡迎關(guān)注億速云行業(yè)資訊頻道。