Was ist die Kanalpuffergröße?

82

Ich versuche, einen asynchronen Kanal zu erstellen, und habe mir http://golang.org/ref/spec#Making_slices_maps_and_channels angesehen .

c := make(chan int, 10)         // channel with a buffer size of 10

Was bedeutet es, dass die Puffergröße 10 beträgt? Was genau repräsentiert / begrenzt die Puffergröße?

go channel

— Tech163
quelle

Siehe hier und weiter

— Ivan Black

Siehe hier auch hilfreich. Sehr direkt und leicht zu verstehen :)

— Ardi Nusawan

157

Die Puffergröße ist die Anzahl der Elemente, die ohne Sendeblockierung an den Kanal gesendet werden können. Standardmäßig hat ein Kanal eine Puffergröße von 0 (Sie erhalten dies mit make(chan int)). Dies bedeutet, dass jeder einzelne Sendevorgang blockiert wird, bis eine andere Goroutine vom Kanal empfängt. Ein Kanal der Puffergröße 1 kann 1 Element enthalten, bis Blöcke gesendet werden

c := make(chan int, 1)
c <- 1 // doesn't block
c <- 2 // blocks until another goroutine receives from the channel

— Lily Ballard
quelle

21

Gute Antwort. Effective Go hat ein schönes Kapitel mit dem Titel "Concurrency", das auf Kanälen erklärt wird. Sehr zu empfehlen: golang.org/doc/effective_go.html

— Levi

Ich spiele damit herum und mache (chan int, 1), dass 3 Werte vor dem Blockieren in meinen Kanal übergeben werden (Testen mit log.Printlns), und die Standardeinstellung ist, 2 vor dem Blockieren einzulassen. Irgendeine Idee warum:

— Mauricio

@ Mauricio Das klingt ziemlich komisch. Ich habe gerade Go 1.8.3 lokal getestet und auch die "Try Go" -Funktionalität bei golang.org verwendet . In beiden Fällen verhält es sich immer noch so, wie es in meiner Antwort dokumentiert ist.

— Lily Ballard

1

Ich freue mich über die Antwort, habe aber den Datendruck auf meiner Konsole falsch interpretiert. Es funktioniert wie beschrieben.

— Mauricio

10

Der folgende Code veranschaulicht das Blockieren des ungepufferten Kanals:

// to see the diff, change 0 to 1
c := make(chan struct{}, 0)
go func() {
    time.Sleep(2 * time.Second)
    <-c
}()
start := time.Now()
c <- struct{}{} // block, if channel size is 0
elapsed := time.Since(start)
fmt.Printf("Elapsed: %v\n", elapsed)

Sie können mit dem Code spielen hier .

— Vladimir Bauer
quelle

0

package main

import (
    "fmt"
    "time"
)

func receiver(ch <-chan int) {
    time.Sleep(500 * time.Millisecond)
    msg := <-ch
    fmt.Printf("receive messages  %d from the channel\n", msg)
}

func main() {
    start := time.Now()
    zero_buffer_ch := make(chan int, 0)
    go receiver(zero_buffer_ch)
    zero_buffer_ch <- 444
    elapsed := time.Since(start)    
    fmt.Printf("Elapsed using zero_buffer channel: %v\n", elapsed)

    restart := time.Now()
    non_zero_buffer_ch := make(chan int, 1)
    go receiver(non_zero_buffer_ch)
    non_zero_buffer_ch <- 4444
    reelapsed := time.Since(restart)
    fmt.Printf("Elapsed using non zero_buffer channel: %v\n", reelapsed)
}

Ergebnis:

Empfangen von Nachrichten 444 vom Kanal

Abgelaufen mit dem Kanal zero_buffer: 505.6729ms

Verstrichen mit einem Nicht-Null-Puffer-Kanal: 0s

— user2480972
quelle