Golang geplanter Stopp

Immer mehr Softwaresysteme erfordern regelmäßige Vorgänge wie Datensicherung, Protokollbereinigung, geplante Aufgaben usw. Bei der Implementierung dieser periodischen Vorgänge müssen wir normalerweise Timer verwenden. Golang bietet einen integrierten Timer, aber wie kann man den Timer bei der Durchführung von Timing-Vorgängen zum erforderlichen Zeitpunkt stoppen?

Im Allgemeinen können wir das von Golang bereitgestellte Zeitpaket verwenden, um einen Timer zu generieren. Zum Beispiel:

timer1 := time.NewTimer(time.Second * 5)
<-timer1.C
fmt.Println("Timer 1 expired")

Der obige Code gibt nach 5 Sekunden „Timer 1 abgelaufen“ aus. Das Programm hier erhält nach einer Wartezeit von 5 Sekunden ein Zeitsignal vom Timer-Kanal (timer1.C) und realisiert damit die Aufgabe des Timers. Es ist zu beachten, dass der mit der Funktion time.NewTimer() erstellte Timer standardmäßig automatisch wiederholt wird. Sie müssen timer.Stop() verwenden, um den Timer zu beenden, andernfalls läuft der Timer weiter.

Aber was ist, wenn wir den Timer innerhalb einer bestimmten Zeit stoppen müssen? Wenn wir beispielsweise Daten sichern und die angegebene Sicherungszeit überschritten wird, müssen wir den Timer zwangsweise stoppen und die Sicherungsaufgabe beenden. Zu diesem Zeitpunkt müssen wir das Stoppsignal binden, wenn der Timer generiert wird, und Abbruchinformationen an das Signal senden, wenn es gestoppt werden muss.

// 定时任务函数
func doDataBackup(stopSignal chan bool){
    // 模拟数据备份，并每10秒执行一遍
    for {
        select {
        case <-time.After(time.Second * 10):
            backupData()
        case stop := <-stopSignal:
            if stop {
                fmt.Println("Data backup stopped.")
                return
            }
        }
    }
}

func main() {
    stopSignal := make(chan bool)
    // 每10秒备份一次数据，规定备份时间为50秒
    go doDataBackup(stopSignal)
    time.Sleep(time.Second * 50)
    // 操纵停止信号，结束任务
    stopSignal <- true
}

Im obigen Code haben wir ein Stoppsignal stopSignal in der Funktion doDataBackup() hinzugefügt, um Informationen zum erzwungenen Stopp zu akzeptieren. Wenn wir die Sicherungsaufgabe stoppen müssen, müssen wir nur true an den stopSignal-Kanal senden, und die Sicherungsaufgabe wird zwangsweise gestoppt.

Es ist zu beachten, dass vor dem Senden eines Stoppsignals an den StopSignal-Kanal möglicherweise einige notwendige Vorgänge wie das Speichern von Daten und die Freigabe von Ressourcen erforderlich sind. Diese Vorgänge müssen ausgeführt werden, bevor ein Stoppsignal an den Kanal gesendet wird, da sonst Probleme wie Datenverlust auftreten können.

Es sollte betont werden, dass die oben genannten Sicherungsaufgaben innerhalb einer einzigen Coroutine ausgeführt werden. Wenn wir Aufgaben regelmäßig in mehreren Coroutinen ausführen und diese regelmäßig stoppen müssen, können wir dies mithilfe der sync.WaitGroup- und Kontextpakete von Golang erreichen. Zum Beispiel:

func doTask(ctx context.Context, wg *sync.WaitGroup, id int){
    defer wg.Done()
    fmt.Printf("goroutine %d started.
", id)
    for {
        select {
        case <-time.After(time.Second * 1):
            fmt.Printf("goroutine %d is working.
", id)
        case <-ctx.Done():
            fmt.Printf("goroutine %d is stopped.
", id)
            return
        }
    }
}

func main() {
    wg := sync.WaitGroup{}
    ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
    defer cancel()
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go doTask(ctx, &wg, i)
    }
    wg.Wait()
    fmt.Println("Task completed.")
}

Im obigen Code haben wir drei Coroutinen erstellt. Jede Coroutine führt regelmäßig eine Aufgabe aus und steuert das Schließen der Coroutine durch den eingehenden Kontext. Verwenden Sie sync.WaitGroup, um sicherzustellen, dass alle Coroutine-Aufgaben abgeschlossen sind, bevor das Programm beendet wird. Verwenden Sie im Kontext die Funktion WithTimeout(), die festlegt, dass die maximale Ausführungszeit der Aufgabe 5 Sekunden beträgt. Wenn die Aufgabe nicht innerhalb von 5 Sekunden abgeschlossen wird, wird die Aufgabe zwangsweise gestoppt und die Coroutine wird beendet.

Oben erfahren Sie, wie Sie Timer in Golang verwenden und einen geplanten Stopp implementieren. Mit diesen Methoden können wir verschiedene periodische Aufgaben einfach implementieren und bei Bedarf die Laufzeit und Stoppzeit der Aufgaben genau steuern.

Das obige ist der detaillierte Inhalt vonGolang geplanter Stopp. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!