Every 10 Seconds

Use in your stack

# crontab has no seconds field, so tile the minute with six offset
# entries. flock -n skips a run if the previous one is still going,
# rather than letting invocations stack up.
* * * * * flock -n /tmp/poll.lock /usr/local/bin/poll.sh
* * * * * sleep 10; flock -n /tmp/poll.lock /usr/local/bin/poll.sh
* * * * * sleep 20; flock -n /tmp/poll.lock /usr/local/bin/poll.sh
* * * * * sleep 30; flock -n /tmp/poll.lock /usr/local/bin/poll.sh
* * * * * sleep 40; flock -n /tmp/poll.lock /usr/local/bin/poll.sh
* * * * * sleep 50; flock -n /tmp/poll.lock /usr/local/bin/poll.sh

# Cleaner on any systemd-based distro — /etc/systemd/system/poll.timer
# AccuracySec is NOT optional here: it defaults to 1min, which would
# collapse this back to once a minute.
#   [Timer]
#   OnCalendar=*-*-* *:*:00/10
#   AccuracySec=1s

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

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

// Simpler for pure intervals:
@Scheduled(fixedRate = 10000) // milliseconds
public void everyTenSecondsFixedRate() {
    // ...
}

Next runs

Pick a timezone to see when this expression fires next.

Variations

Common use cases

• Polling a job queue or webhook backlog on a tight loop.
• Refreshing a near-real-time cache or leaderboard.
• Sampling a sensor or metric at 6× per minute.
• Retrying a flaky downstream call at a short, fixed cadence.

Gotchas

• **Unix crontab cannot do this in one line.** The 5-field format has no seconds field; its minimum interval is one minute. Kubernetes CronJob and GitHub Actions share that limit. The crontab workaround is six entries offset with `sleep` — see the Linux tab above.
• **If you use a systemd timer, you must set `AccuracySec=1s`.** It defaults to **1 minute**, so `OnCalendar=*-*-* *:*:00/10` on its own will not fire every 10 seconds — systemd is free to coalesce those firings into one per minute. This is the single most common reason a sub-minute timer silently doesn't work.
• The `sleep`-offset trick drifts. `sleep 10` starts when cron forks the job, not at the top of the minute, so under load the offset copies wander. Use `flock -n` so a slow run is skipped rather than stacked.
• In Spring, `*/10 * * * * *` is the 6-field form (seconds first) — not to be confused with Unix's `*/10 * * * *`, which means every 10 *minutes*.
• In Quartz, use `0/10 * * * * ?` — `0/10` in the seconds field means "from second 0, every 10 seconds," and `?` fills the unused day-of-week field.
• For a fixed interval like this, `@Scheduled(fixedRate = 10000)` (Spring) or `tokio::time::interval` (Rust) is usually simpler than a cron expression.
• Watch for overlap: if a run can exceed 10 seconds, use `fixedDelay` or an in-flight guard so invocations don't stack.

Frequently asked questions