Einführung
Zweck dieses Labors ist es, Timeouts in Go mit Hilfe von Kanälen und select
zu implementieren.
This tutorial is from open-source community. Access the source code
💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Zweck dieses Labors ist es, Timeouts in Go mit Hilfe von Kanälen und select
zu implementieren.
Wenn Programme sich an externe Ressourcen anschließen oder die Ausführungszeit begrenzen müssen, sind Timeouts wichtig. In diesem Lab wird die Implementierung von Timeouts in Go mit Hilfe von Kanälen und select
behandelt.
select
.time.After
, um auf einen Wert zu warten, der nach Ablauf der Zeitüberschreitung gesendet wird.select
, um mit der ersten empfangenen Nachricht fortzufahren, die bereit ist.## Wenn Sie dieses Programm ausführen, wird die erste Operation
## aufgrund der Zeitüberschreitung fehlschlagen und die zweite
## erfolgreich abgeschlossen werden.
$ go run timeouts.go
timeout 1
result 2
Hier ist der vollständige Code:
// _Timeouts_ sind wichtig für Programme, die sich an externe
// Ressourcen anschließen oder die anderweitig die Ausführungszeit
// begrenzen müssen. Die Implementierung von Timeouts in Go ist dank
// Kanälen und `select` einfach und elegant.
package main
import (
"fmt"
"time"
)
func main() {
// Für unser Beispiel nehmen wir an, dass wir einen externen
// Aufruf ausführen, der sein Ergebnis nach 2 Sekunden auf einem
// Kanal `c1` zurückgibt. Beachten Sie, dass der Kanal gepuffert
// ist, sodass das Senden in der Goroutine nicht blockiert. Dies
// ist ein häufiges Muster, um Goroutine-Lecks zu vermeiden, falls
// der Kanal nie gelesen wird.
c1 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c1 <- "result 1"
}()
// Hier implementiert `select` einen Timeout.
// `res := <-c1` wartet auf das Ergebnis und `<-time.After`
// wartet auf einen Wert, der nach Ablauf der Zeitüberschreitung
// von 1 Sekunde gesendet wird. Da `select` mit der ersten
// empfangenen Nachricht fortfährt, die bereit ist, wird der
// Timeout-Fall eintreten, wenn die Operation länger als die
// zugelassene 1 Sekunde dauert.
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(1 * time.Second):
fmt.Println("timeout 1")
}
// Wenn wir einen längeren Timeout von 3 Sekunden zulassen,
// wird die Nachricht von `c2` empfangen und das Ergebnis
// ausgegeben.
c2 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c2 <- "result 2"
}()
select {
case res := <-c2:
fmt.Println(res)
case <-time.After(3 * time.Second):
fmt.Println("timeout 2")
}
}
In diesem Lab haben wir gelernt, wie man in Go Timeouts mit Hilfe von Kanälen und select
implementiert. Wir haben einen gepufferten Kanal verwendet, um Goroutine-Lecks zu vermeiden, falls der Kanal nie gelesen wird, und time.After
, um auf einen Wert zu warten, der nach Ablauf der Zeitüberschreitung gesendet wird. Wir haben auch select
verwendet, um mit der ersten empfangenen Nachricht fortzufahren, die bereit ist.