golang close chan

In der Go-Sprache ist der Kanal ein sehr wichtiges Konzept. Kanäle bieten eine Möglichkeit, Daten sicher zwischen verschiedenen Goroutinen zu übertragen. Durch die Verwendung von Kanälen können wir verhindern, dass mehrere Goroutinen sicher auf den gemeinsamen Speicher zugreifen, wodurch die Wahrscheinlichkeit von Race Conditions im Programm verringert wird.

Wir wissen, dass bei der Verwendung eines Kanals der Sender Daten in den Kanal schreiben muss und der Empfänger dann Daten vom Kanal liest. Wie kann jedoch sichergestellt werden, dass der Kanal normal geschlossen ist, wenn die Daten im Kanal empfangen wurden? In diesem Artikel besprechen wir, wie Sie einen Kanal schließen und was Sie beim Schließen eines Kanals beachten müssen.

1. Warum müssen Sie den Kanal schließen? Bei der Verwendung eines Kanals verwenden wir normalerweise eine for-Range-Schleife, um die Elemente im Kanal zu iterieren. Hier ist beispielsweise ein Beispiel für das Lesen von Daten aus einem Kanal:

func readData(ch chan int) {
    for data := range ch {
        fmt.Println(data)
    }
}

Im obigen Code haben wir eine for-Range-Schleife verwendet, um die Elemente im Kanal zu durchlaufen. Was aber, wenn der Kanal nie Daten zum Lesen hat? In diesem Fall blockiert die for-Range-Schleife immer das Warten auf das Eintreffen von Daten, was dazu führt, dass das Programm nicht normal beendet wird.

Wir brauchen also eine Möglichkeit, den Kanal zu schließen, damit das Programm nach dem Lesen aller Daten ordnungsgemäß beendet werden kann. Darüber hinaus kann das Schließen des Kanals den Empfänger auch daran erinnern, dass auf dem Kanal keine Daten verfügbar sind, wodurch unnötige Blockierungs- oder Deadlock-Situationen verhindert werden.

2. So schließen Sie den Kanal

In der Go-Sprache können Sie die integrierte Schließfunktion verwenden, um den Kanal zu schließen. Die Signatur der Schließfunktion lautet wie folgt:

func close(ch chan<- Type)

In der obigen Signatur stellt das <-Symbol die Richtung des Kanals dar. ch chan<-Type gibt an, dass ch ein schreibgeschützter Kanal ist und nur zum Senden von Daten verwendet werden kann. Daher kann die Schließfunktion nur zum Schließen eines Kanals verwendet werden, der Daten senden kann.

Hier ist ein Beispiel für die Verwendung der Schließfunktion zum Schließen eines Kanals:

func main() {
    ch := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()
    for data := range ch {
        fmt.Println(data)
    }
}

Im obigen Code erstellen wir zunächst einen ganzzahligen Kanal ch. Dann verwenden wir eine Goroutine, um kontinuierlich Daten an den Kanal zu senden. Nachdem wir 10 Zahlen gesendet haben, rufen wir die Schließfunktion auf, um den Kanal zu schließen.

Als nächstes verwenden wir eine for-Range-Schleife, um die Elemente im Kanal zu durchlaufen und sie auszudrucken. Nachdem alle Daten im Kanal gelesen wurden, wird die for-Range-Schleife automatisch beendet.

3. Ungepufferte Kanäle und gepufferte Kanäle schließen

Im obigen Beispiel haben wir gezeigt, wie man die Schließfunktion verwendet, um den ungepufferten Kanal zu schließen. Beim Schließen eines ungepufferten Kanals müssen alle Daten gelesen werden, sonst kommt es zu einer Blockierung. Wenn Goroutinen den Kanal blockieren, bevor er geschlossen wird, erhalten sie das Signal „Kanal geschlossen“ und werden beendet.

Und wenn wir den gepufferten Kanal schließen, gibt es möglicherweise einige Daten, die nicht gelesen wurden. Beim Schließen eines gepufferten Kanals werden zuerst alle Daten im Kanal gelesen und dann ein Schließsignal an alle Goroutinen gesendet.

Wir können zeigen, wie man einen gepufferten Kanal ausschaltet, indem wir das obige Beispiel modifizieren:

func main() {
    ch := make(chan int, 10)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()
    for data := range ch {
        fmt.Println(data)
    }
}

Im obigen Code deklarieren wir den Kanal ch als gepufferten Kanal und setzen die gepufferte Länge auf 10. Wir verwenden eine Goroutine, um kontinuierlich Daten an den Kanal zu senden. Genau wie beim Schließen des ungepufferten Kanals verwenden wir die Schließfunktion, um den Kanal nach dem Senden von 10 Zahlen zu schließen. In der Haupt-Goroutine verwenden wir eine for-Range-Schleife, um die Daten im Kanal zu durchlaufen und auszugeben.

Wenn es Goroutinen gibt, die auf dem Kanal blockiert sind, nachdem der Kanal geschlossen wurde, erhalten sie das Kanal-geschlossen-Signal und verlassen den Kanal. Wenn sich außerdem ungelesene Daten im Kanal befinden, werden diese Daten nach dem Schließen des Kanals automatisch verworfen.

4. Schließen Sie den Kanal sicher

Beim Schließen des Kanals müssen wir auf einige Dinge achten, um den normalen Betrieb des Programms sicherzustellen:

1 Schließen Sie den Kanal nicht während gleichzeitiger Lese- und Schreibvorgänge.

Wenn in mehreren Goroutinen gleichzeitig Das Lesen und Schreiben desselben Kanals sowie der Aufruf der Schließfunktion in einer der Goroutinen können zu Ausnahmen bei den Lese- und Schreibvorgängen anderer Goroutinen auf dem Kanal führen.

Daher sollten wir bei der Verwendung von Kanälen das gleichzeitige Lesen und Schreiben desselben Kanals in mehreren Goroutinen so weit wie möglich vermeiden. Wenn wir gleichzeitig auf demselben Kanal lesen und schreiben müssen, sollten wir Sperren oder andere Synchronisationsprimitive verwenden, um die Sicherheit der Parallelität zu gewährleisten.

2. Schließen Sie den Kanal nicht wiederholt.

Wenn wir versuchen, denselben Kanal mehrmals zu schließen, tritt eine Panikausnahme auf. Bevor wir den Kanal schließen, sollten wir daher sicherstellen, dass der Kanal noch nicht geschlossen wurde.

Ein bestimmter Kanal kann mithilfe des ok-idit-Werts überprüft werden:

v, ok := <- ch
if ok {
    // ch 未关闭，执行读取操作
} else {
    // ch 已关闭，执行相应的操作
}

Wenn der Kanal geschlossen wurde, ist der ok-Wert falsch. Auf diese Weise können wir prüfen, ob der Kanal geschlossen ist, bevor wir daraus lesen.

3. Schließen Sie nicht den Kanal in der Goroutine, die den Kanal empfängt.

Normalerweise sollten wir die Schließfunktion in der Goroutine verwenden, die Daten sendet, um den Kanal zu schließen. Das Schließen des Kanals in der Goroutine, der die Daten empfängt, kann zu den oben genannten Problemen führen, z. B. zu abnormalen Lese- und Schreibvorgängen auf dem Kanal durch andere Goroutinen.

Deshalb sollten wir bei der Verwendung von Kanälen sicherstellen, dass die Kanäle korrekt verwendet werden, um ähnliche Probleme zu vermeiden.

5. Zusammenfassung

In diesem Artikel haben wir besprochen, wie man einen Kanal schließt und was man beim Schließen eines Kanals beachten muss. Kanäle sind ein sehr wichtiges Parallelitätsprimitiv in der Go-Sprache. Durch die richtige Verwendung von Kanälen können Probleme wie Rennbedingungen und Deadlocks im Programm effektiv vermieden werden.

Daher sollten wir beim Schreiben von Code die Prinzipien und die Verwendung von Kanälen vollständig verstehen und Kanäle sinnvoll nutzen, um gleichzeitige Vorgänge zu erreichen. Beim Schließen des Kanals müssen wir auf Probleme wie den gleichzeitigen Betrieb des Kanals in mehreren Goroutinen und das wiederholte Schließen des Kanals achten, um den korrekten Betrieb des Programms sicherzustellen.

Das obige ist der detaillierte Inhalt vongolang close chan. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!