Wie sollte mit der Verantwortung für das Schließen von Kanälen in Go-Generatoren umgegangen werden?

Idiomatische Implementierung von Generatoren mit Yield

In Go wird die Implementierung von Generatoren mit Yield typischerweise durch eine Kombination aus Goroutinen und Kanälen erreicht. Die Generatorfunktion erstellt eine Goroutine, die Werte über einen Kanal liefert, und die Verbraucherfunktion empfängt diese Werte vom Kanal in einer For-Range-Schleife.

Verantwortung für das Schließen des Kanals

Gemäß der Go Idiome, die Verantwortung für das Schließen des Kanals liegt bei der Generatorfunktion. Da der Generator weiß, wann die Iteration abgeschlossen ist, sollte er den Kanal schließen, um dem Verbraucher zu signalisieren, dass keine weiteren Werte empfangen werden.

Geänderter Code mit Caller Deferring Close()

In Ihrem geänderten Code haben Sie die Verantwortung für das Schließen des Kanals korrekt dem Anrufer zugewiesen, indem Sie ihn in der Generatorfunktion nicht geschlossen haben. Sie sollten jedoch auch den Aufruf close() in der Funktion main() entfernen, da es falsch ist, einen bereits geschlossenen Kanal zu schließen.

package main

import (
    "./lib"
    "fmt"
)

var (
    fruits  = []string{"apple", "banana", "cherry", "durian"}
    banned = "durian"
)

func main() {
    channel := lib.PermutateWithChannel(fruits)
    defer close(channel) // Defer closing the channel

    for myFruits := range channel {
        fmt.Println(myFruits)
        if myFruits[0] == banned {
            break // Break from the loop instead of closing the channel
        }
    }
}

Negative Nebenwirkungen des Schließens eines geschlossenen Kanals

Wenn der Aufrufer den Kanal schließt, führen alle nachfolgenden Versuche, Werte an ihn zu senden, zu einer Laufzeitpanik. Dies liegt daran, dass der Kanal als geschlossen markiert ist und das Senden an einen geschlossenen Kanal illegal ist. Diese Panik hat jedoch keine negativen Nebenwirkungen außer dem Beenden der Goroutine, die versucht hat, Werte zu senden.

Receive-Only Channel Return Type

Um den von der Bibliotheksfunktion zurückgegebenen Kanal auf den Empfang zu beschränken -only, während der Aufrufer es weiterhin schließen kann, können Sie einen neuen Typ einführen, der den Kanal umschließt und nur den Nur-Empfang-Kanal verfügbar macht Kanal:

type ReceiveOnlyChannel <-chan []string

func NewReceiveOnlyChannel(channel <-chan []string) *ReceiveOnlyChannel {
    return (*ReceiveOnlyChannel)(&channel)
}

func PermutateWithChannel(strings []string) *ReceiveOnlyChannel {
    // ... (same as before, except it returns ReceiveOnlyChannel)
}

Indem Sie den Kanal in einen neuen Typ einschließen, können Sie seinen Zugriff darauf beschränken, nur Vorgänge zu empfangen, während der Aufrufer ihn dennoch über die Close()-Methode des Wrapper-Typs schließen kann.

Das obige ist der detaillierte Inhalt vonWie sollte mit der Verantwortung für das Schließen von Kanälen in Go-Generatoren umgegangen werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!