Was ist der richtige Weg, um Hintergrundprozesse in Uber FX ordnungsgemäß herunterzufahren?

Was ist der richtige Weg, um Hintergrundprozesse in Uber FX ordnungsgemäß herunterzufahren? Dies ist ein häufiges Problem, auf das viele Menschen bei der Nutzung von Uber FX stoßen. Als leistungsstarkes Framework für die Verarbeitung von Hintergrundaufgaben bietet Uber FX eine einfache und effektive Möglichkeit, Hintergrundaufgaben zu verwalten und zu verarbeiten. In diesem Artikel stellt Ihnen der PHP-Editor Zimo vor, wie Sie den Hintergrundprozess korrekt schließen, um die Stabilität und den normalen Betrieb des Programms sicherzustellen.

Frageninhalt

Angenommen, ich habe einen Dienst in meiner Uber FX-Anwendung, der einige Hintergrundaktivitäten ausführen soll, beispielsweise das Abfragen einer externen API. Ich kann Hintergrundaufgaben ausführen, indem ich eine Goroutine auslöse, aber wie kann ich sie richtig stoppen?

Als mögliche Umsetzung betrachten wir folgendes Beispiel:

package main

import (
    "context"
    "log"
    "sync"
    "time"

    "go.uber.org/fx"
)

type AwesomeService struct {
    // context to use for background processes
    bg context.Context
    // to trigger background processes stopping
    cancel context.CancelFunc
    // to wait for background processes to gracefully finish
    wg *sync.WaitGroup
}

func New(lc fx.Lifecycle) *AwesomeService {
    bg, cancel := context.WithCancel(context.Background())
    service := &AwesomeService{
        bg:     bg,
        cancel: cancel,
        wg:     new(sync.WaitGroup),
    }

    lc.Append(fx.Hook{
        OnStart: service.start,
        OnStop:  service.stop,
    })
    return service
}

func (s *AwesomeService) start(_ context.Context) error {
    s.runBackgroundProcess()
    log.Println("Start done")
    return nil
}

func (s *AwesomeService) stop(_ context.Context) error {
    s.cancel()
    s.wg.Wait()
    log.Println("Stop done")
    return nil
}

// runBackgroundProcess does some work till context is done.
func (s *AwesomeService) runBackgroundProcess() {
    s.wg.Add(1)
    go func() {
        defer s.wg.Done()
        for {
            select {
            case <-s.bg.Done():
                return
            case <-time.After(1 * time.Second):
                log.Println("Working...")
            }
        }
    }()
}

func main() {
    fx.New(
        fx.Provide(New),
        fx.Invoke(func(*AwesomeService) {}),
    ).Run()
}

Einige Anmerkungen:

• Der Dienst ist über fx.Lifecycle Hooks mit dem Anwendungslebenszyklus verbunden.
• Ich kann mich in der OnStart/OnStop-Methode nicht auf den Kontext verlassen und ihn verwenden, da es sich um unterschiedliche Kontexte handelt und dem Starten/Stoppen von Aktivitäten entspricht, nicht dem Kontext des App-Lebenszyklus.

Bedenken und Fragen:

• Das angegebene Beispiel beschäftigt sich ziemlich intensiv mit der Verfolgung von Hintergrundaufgaben. Darüber hinaus ist das Speichern von Kontext in einer Struktur ein Anti-Pattern. Gibt es eine Möglichkeit, dies zu vereinfachen?
• Soll ich warten, bis die Goroutine fertig ist, wenn keine Ressourcen zum Freigeben vorhanden sind?

Workaround

Meiner Meinung nach ist die Verwendung eines Kontexts in Ordnung, aber Sie können auch ein Shutdown-Signal über einen Kanal an jede gewünschte Go-Routine übermitteln. Siehe Beispielcode unten.

Ja, Sie sollten auch warten, bis die Anzahl der Wartegruppen auf Null zurückgegangen ist, bevor Sie die App vollständig schließen. Sie schließen also zunächst den Kanal und warten dann auf die Wartegruppe.

package main

import (
    "context"
    "log"
    "sync"
    "time"

    "go.uber.org/fx"
)

type AwesomeService struct {
    // channel to shutdown background processes
    shutdown chan struct{}
    // to wait for background processes to gracefully finish
    wg *sync.WaitGroup
}

func New(lc fx.Lifecycle) *AwesomeService {
    service := &AwesomeService{
        shutdown: make(chan struct{}),
        wg:     new(sync.WaitGroup),
    }

    lc.Append(fx.Hook{
        OnStart: service.start,
        OnStop:  service.stop,
    })
    return service
}

func (s *AwesomeService) start(_ context.Context) error {
    s.runBackgroundProcess()
    log.Println("Start done")
    return nil
}

func (s *AwesomeService) stop(_ context.Context) error {
    close(s.shutdown)
    s.wg.Wait()
    log.Println("Stop done")
    return nil
}

// runBackgroundProcess does some work till context is done.
func (s *AwesomeService) runBackgroundProcess() {
    s.wg.Add(1)
    go func() {
        defer s.wg.Done()
        for {
            select {
            case <-s.shutdown:
                return
            case <-time.After(1 * time.Second):
                log.Println("Working...")
            }
        }
    }()
}

func main() {
    fx.New(
        fx.Provide(New),
        fx.Invoke(func(*AwesomeService) {}),
    ).Run()
}

Das obige ist der detaillierte Inhalt vonWas ist der richtige Weg, um Hintergrundprozesse in Uber FX ordnungsgemäß herunterzufahren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!