Go Academy · Leçon

Délais d’expiration et minuteurs

Utiliser time.After et time.Tick avec select

Délais d’expiration et minuteurs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Pourquoi les délais d’attente sont importants

Sans délai d’attente, une routine Go qui attend un canal lent peut rester bloquée indéfiniment. Le paquet time fournit des mécanismes permettant d’ajouter un contrôle temporel aux opérations sur les canaux.

time.After pour un délai d’attente unique

time.After(d) renvoie un canal qui reçoit une valeur après la durée d. Utilisez-le dans un cas de sélection pour interrompre une attente.

select {
case res := <-ch:
    fmt.Println(res)
case <-time.After(2 * time.Second):
    fmt.Println("timed out")
}

Délais d’attente répétés avec time.NewTimer

Pour des temporisateurs réutilisables, utilisez time.NewTimer et appelez Reset après chaque utilisation. Appelez Stop pour éviter de laisser fuir la routine Go du temporisateur.

timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
select {
case <-timer.C:
    fmt.Println("timer fired")
}

time.Tick ou time.NewTicker

time.Tick est pratique, mais laisse fuir le temporisateur sous-jacent. Préférez time.NewTicker afin de pouvoir appeler Stop() pour libérer les ressources.

ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()
for range ticker.C {
    fmt.Println("tick")
}

Temporisateur périodique dans une boucle

Combinez un temporisateur périodique avec un canal d’achèvement pour déclencher un travail périodique qui s’arrête proprement.

ticker := time.NewTicker(time.Second)
done := make(chan struct{})
go func() {
    for {
        select {
        case <-ticker.C:
            doWork()
        case <-done:
            ticker.Stop()
            return
        }
    }
}()

Fuite liée à time.After

time.After crée un nouveau temporisateur à chaque appel, et celui-ci ne peut pas être récupéré par le ramasse-miettes avant son déclenchement. Dans une boucle serrée, utilisez time.NewTimer et Reset pour éviter une fuite de temporisateur.

Échéance ou délai d’attente

Un délai d’attente est une durée relative (« attendre 5 s »). Une échéance est une heure absolue (« attendre jusqu’à 14 h »). Utilisez time.Until(deadline) pour convertir une échéance en durée utilisable avec time.After.

deadline := time.Now().Add(5 * time.Second)
select {
case v := <-ch:
    use(v)
case <-time.After(time.Until(deadline)):
    fmt.Println("deadline exceeded")
}

context.WithTimeout est recommandé

Pour les gestionnaires HTTP et le travail structuré, préférez context.WithTimeout aux délais d’attente bruts fondés sur des canaux : il propage automatiquement l’annulation dans toute la pile d’appels.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Limitation du débit avec un temporisateur périodique

Un temporisateur périodique est le limiteur de débit le plus simple : envoyez une requête par déclenchement. Pour prendre en charge les rafales, préremplissez un canal tamponné et réalimentez-le avec un temporisateur périodique.

requests := make(chan int, 5)
for i := 0; i < 5; i++ { requests <- i }
close(requests)
limiter := time.NewTicker(200 * time.Millisecond)
for req := range requests {
    <-limiter.C
    fmt.Println("request", req)
}

Horloge monotone

Les durées des temporisateurs Go utilisent l’horloge monotone, et non l’horloge système ; elles ne sont donc pas affectées par les réglages de l’horloge système. time.Since et time.Until l’utilisent également.

Arrêter correctement un temporisateur périodique

Après ticker.Stop(), le canal du temporisateur n’est PAS fermé : il cesse simplement de recevoir des valeurs. Si nécessaire, videz toute valeur en attente dans le canal avant de retourner.

Vérification rapide

Pourquoi time.NewTicker est-il préféré à time.Tick ?

Récapitulatif : délais d’attente et temporisateurs périodiques

Points essentiels :

Utilisez time.After pour un délai d’attente unique dans une sélection
Utilisez time.NewTicker pour les tâches répétées ; appelez toujours Stop()
Évitez time.After dans les boucles : cela laisse fuir les temporisateurs
Préférez context.WithTimeout pour les tâches annulables

Questions Fréquemment Posées

La leçon « Délais d’expiration et minuteurs » est-elle gratuite ?

Oui — le texte complet de « Délais d’expiration et minuteurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Délais d’expiration et minuteurs » ?

Utiliser time.After et time.Tick avec select Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Délais d’expiration et minuteurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy