Scheduling & Watching

Periodic work: tickers

For “do something every N”, use a time.Ticker and select on it alongside cancellation so the loop shuts down cleanly. This runs anywhere:

package main

import (
"context"
"fmt"
"time"
)

func main() {
// Cancel after a short while so the demo terminates.
ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
defer cancel()

ticker := time.NewTicker(50 * time.Millisecond)
defer ticker.Stop() // release the runtime timer — don't leak it

n := 0
for {
	select {
	case t := <-ticker.C: // fires every 50ms
		n++
		fmt.Printf("tick %d at +%dms\n", n, t.Sub(t.Truncate(time.Second)).Milliseconds()%1000)
	case <-ctx.Done(): // shutdown / cancellation
		fmt.Printf("stopped after %d ticks\n", n)
		return
	}
}
}

The select { case <-ticker.C ... case <-ctx.Done() ... } shape is the canonical periodic loop: it does work on each tick and exits the instant the context is cancelled (a signal, a deadline, a shutdown). A for { time.Sleep(d) } loop can’t do the second part.

For a one-shot delay use time.NewTimer / time.After; for cron-style calendar schedules (0 3 * * *), reach for an in-process scheduler like github.com/robfig/cron.

Reacting to change: fsnotify

Polling a directory (ReadDir in a loop) is wasteful and laggy. The OS can push you change events through its native API — inotify on Linux, kqueue on BSD/macOS, ReadDirectoryChangesW on Windows — and github.com/fsnotify/fsnotify wraps all three behind one channel:

watcher, _ := fsnotify.NewWatcher()
defer watcher.Close()
watcher.Add("/etc/myapp") // watch a directory (or file)

for {
	select {
	case ev := <-watcher.Events:
		if ev.Op&fsnotify.Write != 0 {
			log.Println("changed, reloading:", ev.Name)
			reloadConfig(ev.Name)
		}
	case err := <-watcher.Errors:
		log.Println("watch error:", err)
	}
}

graph LR
FS["file changes"] -->|"inotify / kqueue / Win32"| W["fsnotify watcher"]
W -->|"Events channel"| APP["reload config / reindex / rotate"]

This is how tools do live config reload, hot asset rebuilds, and watch-mode test runners.

Log rotation

A long-running daemon’s log file grows forever. Rotation caps it: when the file passes a size (or on a schedule), rename it aside (app.log → app.log.1), open a fresh app.log, and delete old generations. Libraries like gopkg.in/natefinch/lumberjack.v2 implement this as an io.Writer you point your logger at:

log.SetOutput(&lumberjack.Logger{
	Filename:   "/var/log/app.log",
	MaxSize:    100, // MB before rotating
	MaxBackups: 3,   // keep app.log.1..3
	MaxAge:     28,  // days
	Compress:   true,
})

See also

• signals — the other way programs react to the outside world.
• processes & exec — running a command on a schedule.
• time (stdlib) — timers, tickers, durations in depth.
• context & cancellation (patterns) — stopping the periodic loop.

Next: the simplest way two processes talk — pipes.

Related topics