So stellen Sie den Timer in der Go-Sprache ein

So stellen Sie einen Timer in der Go-Sprache ein: 1. Erstellen Sie ihn mit der Methode „time.NewTicker()“, wobei der Ticker entsprechend dem eingestellten Intervall ausgelöst wird. 2. Erstellen Sie ihn mit der Methode „time.NewTimer()“. "Methode, bei der nur der Timer das Wort ausführt; 3. Verwenden Sie zum Erstellen "After()".

Die Umgebung dieses Artikels: Windows 7-System, Go1.11.2-Version, dieser Artikel gilt für alle Computermarken.

RECORMENDE: "Golang Tutorial"

Usage of Timer in Go Language

go Language bietet drei Möglichkeiten, Timer im Zeitpaket zu verwenden:

1. Der erste Typ : ticker

// A Ticker holds a channel that delivers `ticks' of a clock
// at intervals.
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}

wird durch time.NewTicker() erstellt. Bei diesem Typ wird der Ticker weiterhin gemäß dem eingestellten Intervall ausgelöst, sofern der Vorgang nicht aktiv beendet wird.

2. Der zweite Typ: timer

// The Timer type represents a single event.
// When the Timer expires, the current time will be sent on C,
// unless the Timer was created by AfterFunc.
// A Timer must be created with NewTimer or AfterFunc.
type Timer struct {
	C <-chan Time
	r runtimeTimer
}

wird durch

time.NewTimer() erstellt kann danach ausgeführt werden. Durch Aufruf von timer.Reset() können Sie den Timer wieder zum Laufen bringen und das Intervall ändern.

3. Der dritte Typ: After()

// After waits for the duration to elapse and then sends the current time
// on the returned channel.
// It is equivalent to NewTimer(d).C.
// The underlying Timer is not recovered by the garbage collector
// until the timer fires. If efficiency is a concern, use NewTimer
// instead and call Timer.Stop if the timer is no longer needed.
func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

Wie Sie dem Code entnehmen können, ist After() eigentlich ein Syntaxzucker für Timer.

Das Folgende demonstriert die Verwendung der drei Methoden durch Code:

---

1. Ticker

ticker := time.NewTicker(time.Second * 1) // 运行时长
    ch := make(chan int)
    go func() {
        var x int
        for x < 10 {
            select {
            case <-ticker.C:
                x++
                fmt.Printf("%d\n", x)
            }
        }
        ticker.Stop()
        ch <- 0
    }()
    <-ch                                    // 通过通道阻塞，让任务可以执行完指定的次数。

Der Ticker wird jede Sekunde ausgelöst, das heißt, jede Sekunde wird ein Inhalt zu ticker.C hinzugefügt schließlich durch Schreiben Sie eine Zahl in ch, um das Programm zu entsperren und mit der Ausführung fortzufahren.

2.Timer

timer := time.NewTimer(time.Second * 1) // timer 只能按时触发一次，可通过Reset()重置后继续触发。
    go func() {
        var x int
        for {
            select {
            case <-timer.C:
                x++
                fmt.Printf("%d,%s\n", x, time.Now().Format("2006-01-02 15:04:05"))
                if x < 10 {
                    timer.Reset(time.Second * 2)
                } else {
                    ch <- x
                }
            }
        }
    }()
    <-ch

3.After()

// 阻塞一下，等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止，打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后， tt 仍继续执行，只是关闭了 tt.C 通道。")

4. Wir können diese grundlegenden Methoden verwenden, um unsere eigene geplante Aufgabenverwaltung zu entwerfen.

type jobFunc2 func(j *job)

type job struct {
    jf     jobFunc2
    params map[string]interface{}
    ch     chan int
}

func NewJob() *job {
    return &job{
        params: make(map[string]interface{}),
        ch:     make(chan int),
    }
}

func (j *job) Run(t time.Duration) {
    ticker := time.NewTicker(time.Second * t)
    go func() {
        for {
            select {
            case <-ticker.C:
                j.jf(j)
            case <-j.ch:
                fmt.Println("收到结束指令")
                ticker.Stop()
                break
            }
        }
    }()

}

func main() {
    j := NewJob()
    j.jf = func(jj *job) {
        fmt.Println("定时任务执行...", time.Now().Format("15:04:05 2006-02-01"), jj.params)
    }
    j.params["p1"] = "第一个参数"
    j.params["p2"] = 100
    j.Run(1)

    // 阻塞一下，等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止，打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后， tt 仍继续执行，只是关闭了 tt.C 通道。")
}

Screenshot einiger Ausführungsergebnisse:

Abschließend möchte ich hinzufügen, dass die Ausführung der Aufgabe über den Kanal beendet wird.

// 阻塞一下，等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止，打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后， tt 仍继续执行，只是关闭了 tt.C 通道。")
    j.ch <- 0
    <-time.After(time.Second * 2)
    fmt.Println("又等了2秒钟...这两秒钟可以看到 tt 没干活了...")

Wenn Sie in der GO-Sprache schreiben, müssen Sie den

Kanal

beherrschen.

Das obige ist der detaillierte Inhalt vonSo stellen Sie den Timer in der Go-Sprache ein. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!