Go select文の優先順位回避策回避策

Question

2つのチャンネルをリッスンして、両方のチャンネルが空になったときにブロックすることを希望します。しかし、両方のチャンネルにデータが含まれている場合は、もう一方のチャンネルが処理される前に排水されることを望みます。

以下の作業例では、を処理する前にすべてoutを流しておきたいと思います。私は優先順位を持たないselect -statementを使用します。問題を回避するにはどうしたらよいでしょうか？出口の前に10個のアウト・バリューをすべて処理しますか？

package main 

import "fmt" 

func sender(out chan int, exit chan bool){ 
    for i := 1; i <= 10; i++ { 
     out <- i 
    } 
    exit <- true 
} 

func main(){ 
    out := make(chan int, 10) 
    exit := make(chan bool) 

    go sender(out, exit) 

    L: 
    for { 
     select { 
      case i := <-out: 
       fmt.Printf("Value: %d\n", i) 
      case <-exit: 
       fmt.Println("Exiting") 
       break L 
     } 
    } 
    fmt.Println("Did we get all 10? Most likely not") 
} 

Answer 1

package main 

import "fmt" 

func sender(out chan int, exit chan bool) { 
    for i := 1; i <= 10; i++ { 
     out <- i 
    } 
    exit <- true 
} 

func main() { 
    out := make(chan int, 10) 
    exit := make(chan bool) 

    go sender(out, exit) 

    for { 
     select { 
     case i := <-out: 
      fmt.Printf("Value: %d\n", i) 
      continue 
     default: 
     } 
     select { 
     case i := <-out: 
      fmt.Printf("Value: %d\n", i) 
      continue 
     case <-exit: 
      fmt.Println("Exiting") 
     } 
     break 
    } 
    fmt.Println("Did we get all 10? I think so!") 
} 

最初の選択のデフォルトの場合は、非ブロック化されます。選択は出口チャネルを見ずに出口チャネルを排水しますが、それ以外の場合は待機しません。アウトチャネルが空の場合、すぐに2番目の選択に降ります。 2番目の選択はブロックしています。どちらかのチャンネルのデータを待ちます。出口が来たら、出口を処理してループを終了させます。データが来ると、ループの先頭に戻り、ドレインモードに戻ります。

Answer 2

別のアプローチ：

package main 

import "fmt" 

func sender(c chan int) chan int { 
     go func() { 
       for i := 1; i <= 15; i++ { 
         c <- i 
       } 
       close(c) 
     }() 
     return c 
} 

func main() { 
     for i := range sender(make(chan int, 10)) { 
       fmt.Printf("Value: %d\n", i) 
     } 
     fmt.Println("Did we get all 15? Surely yes") 
} 

---

$ go run main.go 
Value: 1 
Value: 2 
Value: 3 
Value: 4 
Value: 5 
Value: 6 
Value: 7 
Value: 8 
Value: 9 
Value: 10 
Value: 11 
Value: 12 
Value: 13 
Value: 14 
Value: 15 
Did we get all 15? Surely yes 
$ 

Answer 3

私は1つの、むしろ簡単な回避策を作成しました。それは私が欲しいものを行いますが、他の誰がよりよい解決策を持っている場合、私に知らせてください。代わりに、受信に出たの

exiting := false 
for !exiting || len(out)>0 { 
    select { 
     case i := <-out: 
      fmt.Printf("Value: %d\n", i) 
     case <-exit: 
      exiting = true 
      fmt.Println("Exiting") 
    } 
} 

、私は何もchan outに残っていないことを確認しましたしたら出て行く、終了フラグを立てます。

Answer 4

この言語はこれをネイティブでサポートしており、回避策は必要ありません。これは非常に簡単です。終了チャネルはプロデューサにのみ表示する必要があります。終了すると、プロデューサはチャネルを閉じます。チャネルが空で閉じているときだけ消費者は終了する。これは次のようにチャネルから読み出すことにより可能となる。

v, ok := <-c 

この値vが実際チャネル（ok == true）を読み取ったかどうかを示すブール値をokを設定するか、またはvに設定された場合cが閉じて空（ok == false）なので、チャネルcによって処理される型のゼロ値。チャネルが閉じて空でない場合、vは有効な値になり、okはtrueになります。チャネルが閉じて空の場合、vはチャネルcによって処理されるタイプのゼロ値になり、okはfalseになり、vは役に立たないことを示します。ここで

は説明する例です。

package main 

import (
    "fmt" 
    "math/rand" 
    "time" 
) 

var (
    produced = 0 
    processed = 0 
) 

func produceEndlessly(out chan int, quit chan bool) { 
    defer close(out) 
    for { 
     select { 
     case <-quit: 
      fmt.Println("RECV QUIT") 
      return 
     default: 
      out <- rand.Int() 
      time.Sleep(time.Duration(rand.Int63n(5e6))) 
      produced++ 
     } 
    } 
} 

func quitRandomly(quit chan bool) { 
    d := time.Duration(rand.Int63n(5e9)) 
    fmt.Println("SLEEP", d) 
    time.Sleep(d) 
    fmt.Println("SEND QUIT") 
    quit <- true 
} 

func main() { 
    vals, quit := make(chan int, 10), make(chan bool) 
    go produceEndlessly(vals, quit) 
    go quitRandomly(quit) 
    for { 
     x, ok := <-vals 
     if !ok { 
      break 
     } 
     fmt.Println(x) 
     processed++ 
     time.Sleep(time.Duration(rand.Int63n(5e8))) 
    } 
    fmt.Println("Produced:", produced) 
    fmt.Println("Processed:", processed) 
} 

これは、外出先仕様の「演算子を受け取る」セクションに記載されています。私の場合はhttp://golang.org/ref/spec#Receive_operator

Answer 5

、私は本当に1からのデータを優先させたかったですチャネルを別のチャネルよりも優先し、帯域外の出口信号を持つだけではありません。私は、このアプローチは、潜在的な競合状態ずにうまくいくと思う同じ問題を持つ他の誰の利益のために：

OUTER: 
for channelA != nil || channelB != nil { 

    select { 

    case typeA, ok := <-channelA: 
     if !ok { 
      channelA = nil 
      continue OUTER 
     } 
     doSomething(typeA) 

    case nodeIn, ok := <-channelB: 
     if !ok { 
      channelB = nil 
      continue OUTER 
     } 

     // Looped non-blocking nested select here checks that channelA 
     // really is drained before we deal with the data from channelB 
     NESTED: 
     for { 
      select { 
      case typeA, ok := <-channelA: 
       if !ok { 
        channelA = nil 
        continue NESTED 
       } 
       doSomething(typeA) 

      default: 
       // We are free to process the typeB data now 
       doSomethingElse(typeB) 
       break NESTED 
      } 
     } 
    } 

} 

Answer 6

私はソニアの答えはincorrect.Thisだと思う私の解決策、少し複雑です。

package main 

import "fmt" 

func sender(out chan int, exit chan bool){ 
    for i := 1; i <= 10; i++ { 
     out <- i 
    } 
    exit <- true 
} 

func main(){ 
    out := make(chan int, 10) 
    exit := make(chan bool) 

    go sender(out, exit) 

    L: 
    for { 
     select { 
      case i := <-out: 
       fmt.Printf("Value: %d\n", i) 
      case <-exit: 
       for{ 
        select{ 
        case i:=<-out: 
         fmt.Printf("Value: %d\n", i) 
        default: 
         fmt.Println("Exiting") 
         break L 
        } 
       } 
       fmt.Println("Exiting") 
       break L 
     } 
    } 
    fmt.Println("Did we get all 10? Yes!") 
} 

Answer 7

バッファリングされたチャネルを使用する特定の理由はありますか？make(chan int, 10)？

使用しているバッファなしのチャネルとバッファされたチャネルを使用する必要があります。

10を削除すると、ちょうどmake(chan int)になります。

sender機能で実行が唯一後exit <- true声明にoutチャネルからの最後のメッセージを進めることができますこの方法ではi := <-out文によってデキューされます。その文が実行されていない場合、ゴルーチンではexit <- trueに到達する方法はありません。

Answer 8

別のオプションがあります。

コンシューマコード：提案のための

go func() { 
    stop := false 
    for { 
     select { 
     case item, _ := <-r.queue: 
     doWork(item) 
     case <-r.stopping: 
     stop = true 
     } 
     if stop && len(r.queue) == 0 { 
     break 
     } 
    } 
    }()