So erstellen Sie einen krebsbaren Arbeiter mit Kontext und Kanälen in Go

Verwenden Sie Kontext und Kanäle, um stornierbare Go -Mitarbeiter zu erstellen. 2. Generieren Sie nach Abschluss nach Abschluss, um Lecks zu vermeiden. 3. Die Arbeiter hören CTX.Done () und andere Kanäle in Auswahl als Reaktion auf Stornierungen; 4. Erweiterte Eingangs- und Ausgangskanäle, um Aufgaben zu behandeln und sicherzustellen, dass sie nach der Stornierung nicht blockieren; 5. Zu den Best Practices gehören immer Reinigungsressourcen, die Verwendung von Defer Cancel () und die elegante Freisetzung von Ressourcen, die für die gleichzeitige Aufgabenkontrolle geeignet sind und mit den Sprachgewohnheiten in Eindruck gebracht werden.

In Go ist die Erstellung eines stornierbaren Arbeiters, der seine Ausführung anmutig stoppen kann, wenn sie nicht mehr benötigt werden, eine häufigste Anforderung für gleichzeitige Programme. Mit context und channels können Sie einen sauberen und effizienten Arbeiter erstellen, der auf Stornierungssignale reagiert. Hier erfahren Sie, wie man es richtig macht.

Verständnis der Komponenten: Kontext und Kanäle

GO's context.Context ist so konzipiert, dass sie Termine, Stornierungssignale und andere Anforderungswerte über API-Grenzen hinweg ausführen. In Kombination mit Kanälen können Sie Goroutinen koordinieren und die Arbeit sauber stoppen.

Kanäle werden verwendet, um Daten oder Signale zwischen Goroutinen zu übergeben. In diesem Fall werden wir sie verwenden, um die Arbeitseingabe zu simulieren oder die Fertigstellung zu signalisieren.

Grundstruktur eines stornierbaren Arbeiters

Hier ist ein einfaches Beispiel für einen Arbeiter, der Hintergrundaufgaben ausführt, bis er über einen Kontext anhalten soll:

 Paket Main

importieren (
    "Kontext"
    "fmt"
    "Zeit"
)

func startworker (ctx context.context) {
    // einen Arbeiter simulieren, der regelmäßig funktioniert
    Ticker: = time.newticker (1 * time.second)
    Ticker aufschieben.Stop ()

    für {
        wählen {
        Fall <-ctx.done ():
            fmt.println ("Arbeiter storniert:", ctx.err ())
            Zurückkehren
        Fall <-ticker.c:
            fmt.println ("Arbeit ...")
            // Die tatsächliche Arbeit simulieren
            time.sleep (500 * time.millisecond)
        }
    }
}

func main () {
    // Erstellen Sie einen stornierbaren Kontext
    CTX, Cancel: = context.withcancel (context.background ())
    Defer Cancel () // Sicherstellen

    // den Arbeiter starten
    Gehen Sie Startworker (CTX)

    // Lassen Sie den Arbeiter 5 Sekunden lang laufen
    time.sleep (5 * time.second)

    // den Arbeiter stornieren
    fmt.println ("Stornierarbeiter ...")
    stornieren()

    // Geben Sie etwas Zeit an, um die Stornierungsnachricht zu sehen
    time.sleep (1 * time.second)
}

Schlüsselpunkte in dieser Implementierung

• context.WithCancel erstellt einen Kontext, der explizit abgebrochen werden kann, indem die Funktion cancel() aufgerufen wird.
• Der Arbeiter läuft in einer Schleife und verwendet select , um sowohl den ctx.Done() -Kanal als auch einen ticker anzuhören.
• Wenn cancel() aufgerufen wird, entsperrt ctx.Done() , und der Arbeiter verlässt anmutig.
• Rufen Sie immer cancel() an, um Kontextlecks zu vermeiden, auch wenn Sie erwarten, dass der Kontext auf natürliche Weise abgebrochen wird.

Erweitern Sie sich mit Eingangs- und Ausgangskanälen

Möglicherweise möchten Sie, dass der Arbeitnehmer Jobs aus einem Kanal bearbeiten. Hier erfahren Sie, wie Sie es stornieren können, während Sie noch die Arbeit bearbeiten:

 func startjobworker (ctx context.context, jobchan <-chan int, erledigt chan <- bool) {
    Defer func () {
        Fertig <- True // Signalvervollständigung
    } ())

    für {
        wählen {
        Fall <-ctx.done ():
            fmt.println ("Arbeiter, die geschlossen werden (abgesagt)"))
            Zurückkehren
        Falljob, OK: = <-Jobchan:
            If! OK {
                fmt.println ("Job Channel geschlossen")
                Zurückkehren
            }
            fmt.printf ("Verarbeitungsjob: %d \ n", Job)
            time.sleep (2 * time.second) // Arbeit simulieren
        }
    }
}

func main () {
    CTX, Cancel: = context.withcancel (context.background ())
    Aufhebung stornieren ()

    jobchan: = make (chan int)
    fertig: = make (chan bool)

    Gehen Sie startenjobworker (CTX, Jobchan, fertig)

    // einige Jobs senden
    für i: = 1; i <= 3; ich {
        Jobchan <- i
    }

    time.sleep (2 * time.second)

    // stornieren, bevor alle Jobs erledigt sind
    fmt.println ("Stornierarbeiter ...")
    stornieren()

    // Warten Sie, bis der Arbeiter beendet wird
    <-done
    schließen (jobchan)

    fmt.println ("Hauptausgang")
}

Best Practices

• Verwenden Sie immer context für die Stornierung in langlebigen Goroutinen.
• Verwenden Sie defer cancel() wenn Sie mit WithCancel , WithTimeout oder WithDeadline verwendet werden, um Ressourcenlecks zu verhindern.
• Vermeiden Sie das Blockieren von Sendungen auf Kanälen nach der Stornierung - strukturieren Sie Ihre Schleife so, dass sie sauber ausgeht.
• Wenn der Arbeiter Ressourcen besitzt (wie Dateihandles oder Verbindungen), geben Sie sie nach der Stornierung in einem defer frei.

Zusammenfassung

Das Erstellen eines stornierbaren Arbeiters in GO mit context und Kanälen beinhaltet:

• Übergeben eines context.Context an den Arbeiter.
• Hören auf ctx.Done() in einer select Anweisung.
• Rufen Sie cancel() , wenn Sie den Arbeiter stoppen möchten.
• Optional verwenden Sie Eingangs-/Ausgangskanäle für Arbeit und Ergebnisse.

Dieses Muster wird häufig bei Servern, Hintergrundaufgaben und gleichzeitigen Pipelines verwendet. Es ist einfach, idiotisch und skaliert gut.

Denken Sie im Grunde genommen nur daran: Kontext für Kontrolle, Kanäle für Daten und immer aufräumen .

Das obige ist der detaillierte Inhalt vonSo erstellen Sie einen krebsbaren Arbeiter mit Kontext und Kanälen in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!