Ticker Stop comportement à Golang

Si je suis en allant sur un ticker canal et appelle stop() la chaîne est arrêtée, mais pas fermé.

Dans cet Exemple:

package main

import (
    "time"
    "log"
)

func main() {
    ticker := time.NewTicker(1 * time.Second)
    go func(){
        for _ = range ticker.C {
            log.Println("tick")
        }
        log.Println("stopped")
    }()
    time.Sleep(3 * time.Second)
    log.Println("stopping ticker")
    ticker.Stop()
    time.Sleep(3 * time.Second)
}

Cours d'exécution produit:

2013/07/22 14:26:53 tick
2013/07/22 14:26:54 tick
2013/07/22 14:26:55 tick
2013/07/22 14:26:55 stopping ticker

De sorte que goroutine jamais quitte. Est-il une meilleure façon de gérer ce cas? Dois-je prendre soin que la goroutine jamais quitté?

source d'informationauteur whatupdave

  1. 10

    Signal "fait" sur un deuxième canal et sélectionnez dans votre goroutine entre symbole et fait du canal.

    En fonction de ce que vous voulez vraiment faire une meilleure solution pourrait exister, mais c'est difficile de dire à partir de la réduction de la démo de code.

  2. 11

    Utilisé un deuxième canal Volker suggéré. C'est ce que j'ai terminé la course à pied avec:

    package main

import (
    "log"
    "time"
)

//Run the function every tick
//Return false from the func to stop the ticker
func Every(duration time.Duration, work func(time.Time) bool) chan bool {
    ticker := time.NewTicker(duration)
    stop := make(chan bool, 1)

    go func() {
        defer log.Println("ticker stopped")
        for {
            select {
            case time := <-ticker.C:
                if !work(time) {
                    stop <- true
                }
            case <-stop:
                return
            }
        }
    }()

    return stop
}

func main() {
    stop := Every(1*time.Second, func(time.Time) bool {
        log.Println("tick")
        return true
    })

    time.Sleep(3 * time.Second)
    log.Println("stopping ticker")
    stop <- true
    time.Sleep(3 * time.Second)
}
  3. 1

    vous pouvez faire comme ceci. 

    package main

import (
    "fmt"
    "time"
)

func startTicker(f func()) chan bool {
    done := make(chan bool, 1)
    go func() {
        ticker := time.NewTicker(time.Second * 1)
        defer ticker.Stop()
        for {
            select {
            case <-ticker.C:
                f()
            case <-done:
                fmt.Println("done")
                return
            }
        }
    }()
    return done
}

func main() {
    done := startTicker(func() {
        fmt.Println("tick...")
    })
    time.Sleep(5 * time.Second)
    close(done)
    time.Sleep(5 * time.Second)
}
  4. 0

    Si Vous devez enregistrer plus d'espace, utilisez les canaux de vide structs - struct{} qui ne coûte pas de mémoire. Et comme mentionné ci-dessus ne.t envoyer quelque chose en elle - il suffit de fermer, ce qui en fait envoyer la valeur zéro.