Suggest an edit

Improve this article

Refine the answer for “Timer execution guarantee”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## Short answer

**No, you cannot guarantee the exact execution time of a timer**
in JavaScript (`setTimeout`, `setInterval`, etc.).

The reason is simple: **JavaScript is single-threaded**, and a timer's execution depends on the state of the **event loop** and how busy the **call stack** is.

## Why this happens

When you call:

```javascript
setTimeout(fn, 1000);
```

JS **does not promise** that `fn` will run **after exactly 1000 ms**.
It only **puts a task in the queue** to be run **no earlier** than 1000 ms from now.

If, at the moment the timer "fires", the call stack is busy,
the callback waits its turn.

## Example

```javascript
console.log('Start');

setTimeout(() => console.log('Timer 1s'), 1000);

const start = Date.now();
while (Date.now() - start < 3000) {} // block the thread for 3 seconds

console.log('End');
```

**Result:**

```javascript
Start
(3 seconds pause)
End
Timer 1s
```

Even though the timer was set for 1 second, it only fired **after 3 seconds**.
Why? Because the engine **could not run it earlier** - the stack was busy with the loop.

## Minimum delay (throttling)

Even `setTimeout(fn, 0)` does not run the code "immediately" - there is still a minimum delay:

- In browsers: usually **4 ms** (per the HTML Living Standard),
- In Node.js: it can be less, but it is still **not instant**.

In addition, if the browser tab is inactive, the delay can be increased (up to 1000 ms or more) - browsers **save resources**.

## Example with setInterval

`setInterval()` **also does not guarantee** exact intervals.
If the function inside it takes longer than the interval itself, the calls get "backed up" and run late.

```javascript
setInterval(() => {
  const start = Date.now();
  while (Date.now() - start < 1500) {} // block for 1.5 sec
  console.log('tick');
}, 1000);
```

The interval is 1 second, but the function takes 1.5 sec,
so the "ticks" happen with a real delay of 1.5, 3.0, 4.5... sec.

## Why it cannot be exact

| Reason | Explanation |
|---|---|
| **JS is single-threaded** | While code is running, other tasks wait |
| **Event loop** | Timers only get placed in the queue - they do not fire instantly |
| **Browser limits** | There is a minimum delay, and background tabs get throttled |
| **CPU load** | Under heavy load, timers run later |
| **OS scheduler** | JS does not control system time, it only "asks" to run a task later |

## What you can do

If you need **maximum precision** (for example, in animation or synchronization), you can use alternatives:

1. `performance.now()` - measures precise time in milliseconds (with microsecond resolution):

```javascript
  const start = performance.now();
  // ...
  const elapsed = performance.now() - start;
  ```
2. `requestAnimationFrame()` - runs a callback before each frame (~60 times per second),
ideal for smooth animations.
3. `setTimeout` **with drift compensation** (delay correction):

```javascript
  const start = Date.now();
  let count = 0;

function tick() {
    count++;
    const expected = start + count * 1000;
    const drift = Date.now() - expected;

console.log(`tick ${count}, drift: ${drift}ms`);

setTimeout(tick, 1000 - drift);
  }

tick();
  ```
This approach accounts for "lateness" and evens out the intervals.

## Summary

| Question | Answer |
|---|---|
| Can you guarantee the exact time of a timer? | No |
| Why? | JS single-threadedness, the event loop, minimum delays, and load |
| What actually happens? | The timer is added to the task queue and runs later |
| Is there an alternative for precision? | `requestAnimationFrame`, `performance.now`, drift compensation |

Markdown · drag & drop images · ⌘B / ⌘I shortcuts588 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.