Go Academy · Lección

Tiempos de espera y tickers

Uso de time.After y time.Tick con select

Tiempos de espera y tickers es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Por qué son importantes los tiempos de espera

Sin tiempos de espera, una goroutine que espera un canal lento puede bloquearse para siempre. El paquete time proporciona primitivas para añadir control basado en el tiempo a las operaciones de canal.

time.After para tiempos de espera únicos

time.After(d) devuelve un canal que recibe un valor después de la duración d. Utilícelo en un caso de select para cancelar una espera.

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

Tiempos de espera repetidos con time.NewTimer

Para temporizadores reutilizables, utilice time.NewTimer y llame a Reset después de cada uso. Llame a Stop para evitar que la goroutine del temporizador quede activa innecesariamente.

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

time.Tick frente a time.NewTicker

time.Tick es práctico, pero produce una fuga del ticker subyacente. Prefiera time.NewTicker para poder llamar a Stop() y liberar recursos.

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

Ticker en un bucle

Combine un ticker con un canal done para ejecutar tareas periódicas que se detengan correctamente.

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

Fuga de time.After

time.After crea un temporizador nuevo en cada llamada y este no puede ser recolectado por el recolector de basura hasta que se activa. En un bucle ajustado, utilice time.NewTimer + Reset para evitar una fuga de temporizadores.

Plazo límite frente a tiempo de espera

Un tiempo de espera es una duración relativa («esperar 5 s»). Un plazo límite es un momento absoluto («esperar hasta las 14:00»). Utilice time.Until(deadline) para convertir un plazo límite en una duración para 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")
}

Se recomienda context.WithTimeout

Para controladores HTTP y trabajos estructurados, prefiera context.WithTimeout a los tiempos de espera basados directamente en canales: propaga la cancelación automáticamente por toda la pila de llamadas.

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

Limitación de la tasa con Ticker

Un ticker es el limitador de tasa más sencillo: envía una solicitud por cada tick. Para admitir ráfagas, rellene previamente un canal con búfer y vuelva a llenarlo con un ticker.

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)
}

Reloj monotónico

Las duraciones de los temporizadores de Go utilizan el reloj monotónico, no el reloj de pared, por lo que no se ven afectadas por los ajustes del reloj del sistema. time.Since y time.Until también lo utilizan.

Detener correctamente un ticker

Después de ticker.Stop(), el canal del ticker NO se cierra: simplemente deja de recibir valores. Si es necesario, drene cualquier valor pendiente del canal antes de regresar.

Comprobación rápida

¿Por qué se prefiere time.NewTicker a time.Tick?

Repaso: tiempos de espera y tickers

Puntos clave:

time.After para un tiempo de espera único en select
time.NewTicker para tareas repetitivas; llame siempre a Stop()
Evite time.After en bucles: produce fugas de temporizadores
Prefiera context.WithTimeout para trabajos cancelables

Preguntas frecuentes

¿La lección «Tiempos de espera y tickers» es gratis?

Sí — el texto completo de «Tiempos de espera y tickers» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tiempos de espera y tickers»?

Uso de time.After y time.Tick con select Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Tiempos de espera y tickers»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy