Wie können verkettete Kanaloperationen in der „select'-Anweisung von Go zu Deadlocks und Datenverlust führen?

Verkettung von Kanaloperationen in einem Single-Select-Fall: Analyse einer potenziellen Falle

In Go bietet die Select-Anweisung eine bequeme Möglichkeit, mehrere zu multiplexen Kanäle. Stellen Sie sich das folgende Szenario vor: Wir haben zwei Kanäle, A und B, die Nachrichten in unterschiedlichen Intervallen übertragen. Wir möchten einen Fan-In-Kanal erstellen, der Nachrichten sowohl von A als auch von B empfängt.

Der folgende Code zeigt dies:

func fanIn(input1, input2 <-chan string) <-chan string {
    ch := make(chan string)
    go func() {
        for {
            select {
                case t := <-input1:
                    ch <- t
                case t := <-input2:
                    ch <- t
            }
        }
    }()

    return ch
}

Wenn wir diesen Code ausführen, erwarten wir den Empfang von Nachrichten von beiden Kanälen in verschachtelter Form. Wenn wir jedoch die Select-Case-Anweisung wie folgt ändern, stoßen wir auf ein unerwartetes Verhalten:

func fanIn(input1, input2 <-chan string) <-chan string {
    ch := make(chan string)
    go func() {
        for {
            select {
                case ch <- <-input1:
                case ch <- <-input2:
            }
        }
    }()

    return ch
}

In diesem Fall empfangen wir einige Nachrichten korrekt, aber dann kommt es zu Werteverlusten und schließlich zu einem Deadlock. Der Grund für dieses Verhalten liegt in der grundlegenden Funktionsweise von „select“.

Bei „select“ ist nur ein Lese- oder Schreibvorgang für einen Kanal nicht blockierend. Alle anderen Vorgänge verhalten sich normal. Im geänderten Code enthalten beide Fälle Kanalschreibvorgänge, die nicht blockierend sind. Dies führt zu einer Situation, in der Nachrichten von Eingabekanälen in der Warteschlange stehen, der Fan-In-Kanal jedoch jeweils nur eine konsumieren kann.

Dadurch können Nachrichten verworfen werden und beim Fan-In kommt es zu einem Deadlock Der Kanal hat keine Autoren und der Leser wartet auf weitere Werte.

Um dieses Problem zu vermeiden, ist es wichtig zu verstehen, dass in einer SELECT-Anweisung nur eine Operation nicht blockierend sein sollte. Wenn Sie mehrere Kanaloperationen in einem einzelnen Auswahlfall ausführen müssen, sollten Sie die Verwendung einer nicht blockierenden Auswahlhilfsfunktion wie dieser in Betracht ziehen:

func nonBlockingSelect(cases []reflect.SelectCase) (chosen int, recv interface{}, ok bool) {
    for i, c := range cases {
        if c.Dir == reflect.SelectSend && c.Chan == nil {
            continue
        }
        v, ok := reflect.Select(cases)
        return v.Index, v.Elem().Interface(), ok
    }

    return -1, nil, false
}

Dann kann die modifizierte Fan-In-Funktion wie folgt umgeschrieben werden:

func fanIn(input1, input2 <-chan string) <-chan string {
    ch := make(chan string)
    go func() {
        for {
            select {
                case c1 := <-input1:
                    nonBlockingSelect([]reflect.SelectCase{
                        {Dir: reflect.SelectSend, Chan: reflect.ValueOf(ch), Send: reflect.ValueOf(c1)},
                    })
                case c2 := <-input2:
                    nonBlockingSelect([]reflect.SelectCase{
                        {Dir: reflect.SelectSend, Chan: reflect.ValueOf(ch), Send: reflect.ValueOf(c2)},
                    })
            }
        }
    }()

    return ch
}

Durch die Verwendung des nicht blockierenden Select-Helfers wird sichergestellt, dass nur ein Kanalvorgang nicht blockierend ist, wodurch das Problem verlorener Werte und Deadlocks vermieden wird.

Das obige ist der detaillierte Inhalt vonWie können verkettete Kanaloperationen in der „select'-Anweisung von Go zu Deadlocks und Datenverlust führen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!