Erfahren Sie mehr über die Verwendung von Go Context

Kontext in der Go-Sprache ist sehr einfach zu verwenden. Fast alle Go-Programme verwenden ihn, um Werte im Anforderungsbereich zu übergeben. Es handelt sich um ein leichtgewichtiges Objekt, das die Weitergabe von anforderungsbezogenen Werten über API-Grenzen hinweg ermöglicht, einschließlich Abbruchsignalen, Fristen, Anforderungs-IDs usw.

In diesem Artikel werfen wir einen detaillierten Blick auf die Verwendung von Go Context, verstehen seine Vorteile und wie Sie damit die Leistung und Robustheit Ihrer Anwendung verbessern können.

Was ist Go-Kontext?

Go Context ist eine Standardbibliothek in der Go-Sprache, die zum Verwalten von Anforderungsbereichswerten verwendet wird. Es bietet Anwendungen eine einfache und transitive Methode zum Übergeben angeforderter Variablen zwischen Goroutinen. Es wird hauptsächlich zum Übergeben von Stornierungsanfragen, Zeitüberschreitungslimits, Tracking-Protokollen, Anfragekontext, Anfragedaten usw. verwendet.

Im Gegensatz zu Context in anderen Programmiersprachen hat Go Context einige ganz besondere Eigenschaften:

• Es ist Thread-sicher.
• Sein Wert kann über Goroutinen hinweg weitergegeben werden.
• Es kann abgebrochen oder mit einer Zeitüberschreitung versehen werden, um langwierige oder unaufhaltsame Vorgänge zu verhindern.
• Es kann auch verwendet werden, um die Stornierung von Anfragen und die Stornierung tatsächlicher Vorgänge zu trennen.

Nutzungsszenarien

Go Context ist ein sehr vielseitiges Tool, das für Anwendungen in verschiedenen Szenarien verwendet werden kann, darunter:

1. Webanwendungen

Webanwendungen gehören zu den häufigsten Nutzungsszenarien. Es erleichtert die Verwaltung des Kontexts und der anforderungsspezifischen Metadaten, die für die Verarbeitung von HTTP-Anfragen erforderlich sind. Während der HTTP-Anforderungsverarbeitung wird der Kontext verwendet, um Anforderungs-IDs, Anforderungszeitüberschreitungen, Abbruchsignale usw. über Handler hinweg zu übergeben. Kontext wird beispielsweise verwendet, um den Sitzungsstatus bei der Verarbeitung von Websocket-Verbindungen zu verfolgen.

2. Hintergrunddienstanwendung

Hintergrunddienstanwendungen müssen möglicherweise mehrere APIs durchlaufen, um Daten an externe Systeme bereitzustellen, und sind für solche Anwendungen die beste Wahl. Hierzu können Sie die Standardfunktion Context WithCancel nutzen. Wenn alle Goroutinen diesen Kontext verwenden, ist nur ein Rückruf erforderlich, um alle Abonnements zu stoppen und Ressourcen zu bereinigen.

3. Datenbank- und Dateioperationen

Go Context ist ein ideales Tool für die Handhabung großer Datei- und DB-Operationen, da diese Operationen ressourcen- und E/A-intensiv sein können. In diesem Fall wird der Kontext verwendet, um den Vorgang abzubrechen, um Fehler und Laufzeitfehler zu vermeiden.

4. Verteilte Anwendungen

In der Microservice-Architektur wird Kontext häufig verwendet, um anforderungsbezogene Informationen von der API an die Aufrufkette jedes Dienstes zu übergeben. In diesem Fall wird die Trace-ID im Kontext gespeichert und beim Herstellen einer Verbindung zu mehreren Diensten übergeben. Dies erleichtert die Rückverfolgung der gesamten Anforderungszeile.

Verwendung von Kontext

Da wir nun die Grundlagen von Go Context verstanden haben, werden wir untersuchen, wie wir es zum Verwalten von anforderungsbezogenen Werten verwenden können.

1. Erstellen Sie einen Kontext

In der Go-Sprache können Sie context.Background() verwenden, um einen leeren Kontext der obersten Ebene zu erstellen. Dieser Kontext ist global unabhängig und enthält keine Werte.

ctx := context.Background()

Sie können auch die Funktion WithValue() verwenden, um einen Kontext mit einem Wert zu erstellen. Sie können beispielsweise einen HTTP-Anforderungsverarbeitungskontext mit Anforderungsdaten und Zeitlimits erstellen. Die Funktion

ctx := context.WithValue(
        context.Background(),
        "requestId",
        uuid.New())

ctx.Value() verwendet diesen Kontext, um den Wert des Kontexts abzurufen. Im folgenden Beispiel können wir Kontextinformationen erhalten, indem wir eine eindeutige Kennung anfordern.

requestId, ok := ctx.Value("requestId").(value string)

2. Timeout-Signal

Mit der Funktion context.WithDeadline oder context.WithTimeout können Sie auch ein Timeout-Signal auf den Kontext anwenden, um lang laufende Prozesse zu vermeiden. Die Funktion

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

cancel() wird verwendet, um den Abbruchstatus des Kontexts zu markieren. Der Kontext wird automatisch abgebrochen, wenn ein Timeout-Ereignis auftritt.

select {
case <-timeOutCtx.Done():
         if err := timeOutCtx.Err(); err != nil {
                   fmt.Println("Time out due to: ", err)
         }
case <-time.After(5 * time.Second):
       fmt.Println("Hooray! Request done within 5 sec")
}

In diesem Beispiel erstellen wir einen Timeout-Kontext von 10 Sekunden. Die Select-Anweisung wartet auf Operationen auf zwei Kanälen. Done()-Methode, die ein Signal ausgibt, wenn der Kontext abgebrochen wird oder eine Zeitüberschreitung auftritt.

Wir senden eine kurze Nachricht über den Timer-Kanal und warten 5 Sekunden. Da das zweite Argument unserer context.WithTimeout()-Funktion 10 Sekunden beträgt, sollte nur die erste Route in der select-Anweisung ausgeführt werden.

3. Context Cancelable

Context ist eine Funktion zum Löschen von Signalen, die bei lang laufenden Prozessen verwendet werden kann, um unerwartete Belastungen des Systems zu vermeiden.

Im folgenden Codeausschnitt verwenden wir context.WithCancel(), um einen Kontext zu erstellen, und verwenden dann die Funktion cancel(), um den Abbruchstatus des Kontexts zu markieren. Wenn die angegebene Goroutine abgeschlossen ist, bevor der Kontext abgebrochen wird, wird ihr Abschlusssignal über die Methode Done() gesendet.

ctx, cancel := context.WithCancel(context.Background())

go func(ctx context.Context) {
      select {
             case <-ctx.Done():
                 fmt.Println("Exiting goroutine")
                 return
             default:
                  fmt.Println("Processing...")
       }
}(ctx)

// Exit after 5 sec
time.AfterFunc(5*time.Second, cancel)

Hier verwenden wir Done() und den Standardzweig in Goroutine. Wenn der Kontext abgebrochen wird oder eine Zeitüberschreitung auftritt, gibt die Methode Done() ein Signal zurück und ruft die Funktion cancel() auf, um die Ausführung der Goroutine abzubrechen.

In der Hauptfunktion verwenden wir die Funktion time.AfterFunc(), um die Funktion cancel() dieses Kontexts aufzurufen und den Abbruchstatus des Kontexts zu markieren. Dadurch wird der Goroutine-Abbruch nach 5 Sekunden ausgelöst.

4. Context超时和取消

在处理请求的时间，我们通常需要确保 goroutine 不会无限期地等待，而需要在可接受的时间范围内执行操作。

在下面的代码段中，我们将使用 context.WithTimeout() 函数创建一个带有 5 秒超时限制的 Context。

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

select {
    case <-time.After(5 * time.Second):
       fmt.Println("Request completed")
    case <-ctx.Done():
         fmt.Println("Exit due to: ", ctx.Err())
}

我们也使用了 cancel() 函数，确保 Context 被取消时自动触发。

为了模拟一个长时间的操作，我们使用 time.After(channel)。 当 goroutine 执行时间超过 2 秒时，Context 始终会被取消。 select 语句通过检查两个 channel 的操作结果而“安全地”退出。

总结

在 Go 语言中，Context 是通用工具，用于管理请求范围的数据。它提供了一种非常强大，灵活的方法，以跨 API 边界传递请求范围的值，如取消信号、截止日期、请求 ID 等。

在本文中，我们深入探讨了 Go Context 的一些实际用例，并讨论了一些最佳实践，以优化应用程序的可维护性和性能。

随着应用程序和网络的规模增长，Context 的正确使用和管理变得非常重要。如果用得当，它可以提高应用程序的健壮性和性能，从而确保进行细粒度的请求管理。

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über die Verwendung von Go Context. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!