Every 5 Seconds

Use in your stack

# Twelve offset entries would tile the minute, but don't do that.
# One per-minute entry running an internal loop is the honest form:
* * * * * for i in $(seq 12); do /usr/local/bin/poll.sh & sleep 5; done

# The & matters — without it a slow run pushes the whole cadence out.
# Add flock if overlapping runs would be harmful:
# * * * * * for i in $(seq 12); do flock -n /tmp/poll.lock /usr/local/bin/poll.sh & sleep 5; done

# Cleanest on a systemd distro — /etc/systemd/system/poll.timer
# AccuracySec defaults to 1min and MUST be lowered, or systemd
# coalesces all twelve firings into one.
#   [Timer]
#   OnCalendar=*-*-* *:*:00/05
#   AccuracySec=1s

{
  "schedule": {
    "cron": "0/5 * * * * ?",
    "timezone": "UTC"
  }
}

// 6-field: second minute hour day-of-month month day-of-week
@Scheduled(cron = "*/5 * * * * *")
public void everyFiveSeconds() {
    // ...
}

// Simpler for pure intervals — no cron parser needed:
@Scheduled(fixedRate = 5000) // milliseconds
public void everyFiveSecondsFixedRate() {
    // ...
}

Next runs

Pick a timezone to see when this expression fires next.

Variations

Common use cases

• Polling a fast-changing queue or message broker for new work.
• Updating a live dashboard or real-time metric during development.
• Health-checking a low-latency service that needs sub-minute detection.
• Draining a buffer to a downstream system on a tight cadence.

Gotchas

• **Unix crontab cannot do this in one line.** The 5-field format has no seconds field; its minimum interval is `* * * * *` (every minute). Kubernetes CronJob and GitHub Actions inherit the same limit.
• **Five seconds is where the `sleep`-offset trick stops being reasonable.** Tiling the minute takes twelve crontab entries, eleven of which are sleeping processes, producing twelve log streams for one logical job. At that point you have written a loop and distributed it across a config file — write the loop instead.
• **A systemd timer needs `AccuracySec=1s` here.** It defaults to **1 minute**, so `OnCalendar=*-*-* *:*:00/05` alone will not fire every 5 seconds; systemd coalesces the firings. The timer looks right and runs 12× less often than intended.
• In Spring, `*/5 * * * * *` is the 6-field form (seconds first). Don't confuse it with Unix's 5-field `*/5 * * * *`, which means every 5 *minutes*.
• In Quartz, use `0/5 * * * * ?` — the `0/5` seconds field means "starting at second 0, every 5 seconds," and `?` fills the unused day-of-week field.
• For anything this frequent, a `fixedRate`/`fixedDelay` loop is often simpler and cheaper than a cron parser. Use `@Scheduled(fixedRate = 5000)` in Spring or `tokio::time::interval` in Rust.
• Overlap is a real risk at 5-second cadence — if the job ever takes longer than 5 seconds, runs stack up. Prefer `fixedDelay` (waits for the previous run) or an in-flight guard.

Frequently asked questions