Maison >développement back-end >Golang >Comment régler la minuterie en langue Go

Comment régler la minuterie en langue Go

藏色散人
藏色散人original
2020-12-16 10:59:084895parcourir

Comment définir une minuterie en langage Go : 1. Créez-la via la méthode "time.NewTicker()", où le ticker sera déclenché en fonction de l'intervalle défini 2. Créez-la via la méthode "time ; .NewTimer()", où le minuteur n'exécutera qu'un seul mot ; 3. Utilisez "After()" pour créer.

Comment régler la minuterie en langue Go

L'environnement de cet article : Système Windows 7, version Go1.11.2, cet article est applicable à toutes les marques d'ordinateurs.

Recommandé : "Tutoriel Golang"

L'utilisation des minuteries en langage Go

Le langage GO propose trois façons d'utiliser les minuteries dans le package time :

1. 🎜>

// 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
}
est créé via

time.NewTicker() Dans ce type, le ticker sera déclenché en continu selon l'intervalle défini. à moins que l'opération ne soit activement terminée.

2. Le deuxième type :

minuterie

// 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
}
Pass

time.NewTimer() est créé. Dans ce type, le timer ne sera exécuté qu'une seule fois. Bien entendu, il peut être appelé après l'exécution en appelant timer.Reset. () Faites fonctionner à nouveau la minuterie avec la possibilité de modifier l'intervalle de temps.

3. Le troisième type : Après()

// 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
}
Comme vous pouvez le voir dans le code, Après( ) en fait, c'est un sucre de syntaxe pour Timer.


Ce qui suit démontre l'utilisation des trois méthodes via le 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                                    // 通过通道阻塞,让任务可以执行完指定的次数。
Le ticker tous les 1 second Déclenché une fois, c'est-à-dire qu'un contenu sera ajouté à ticker.C toutes les secondes. Enfin, en écrivant un nombre dans ch, le programme sera débloqué et poursuivra son exécution.

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 Nous pouvons utiliser ces bases. méthode pour concevoir votre propre gestion des tâches planifiées.

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 通道。")
}
Capture d'écran de quelques résultats d'exécution :

Enfin, je voudrais ajouter que l'exécution de la tâche se termine via le canal.

// 阻塞一下,等待主进程结束
    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 没干活了...")

Lorsque vous écrivez en langage GO, vous devez maîtriser l'utilisation du
canal

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn