1Thread calls sleep(500ms)
2    |
3    v
4[Kernel] Remove thread from run queue
5    |
6    v
7[Kernel] Insert timer entry into timer wheel (expire at now + 500ms)
8    |
9    v
10[Scheduler] Runs other threads (sleeping thread uses 0 CPU)
11    |
12    v
13[Hardware timer interrupt fires]
14    |
15    v
16[Kernel] Timer expired → move thread to ready queue
17    |
18    v
19[Scheduler] Eventually schedules the thread (may add small delay)
20    |
21    v
22Thread resumes execution

1import time
2
3# Sleep for 1 second
4time.sleep(1.0)
5
6# Sleep for 500 milliseconds
7time.sleep(0.5)
8
9# Sub-millisecond sleep (accuracy depends on OS)
10time.sleep(0.001)  # 1 ms
11
12# Under the hood: Python calls the C library's nanosleep() on Linux
13# or Sleep() on Windows. The GIL is released during sleep.

1#include <unistd.h>
2#include <time.h>
3
4// sleep() — second resolution
5sleep(2);  // Sleep for 2 seconds
6
7// usleep() — microsecond resolution (deprecated)
8usleep(500000);  // Sleep for 500ms
9
10// nanosleep() — nanosecond resolution (preferred)
11struct timespec req = {.tv_sec = 0, .tv_nsec = 500000000};  // 500ms
12struct timespec rem;
13nanosleep(&req, &rem);  // rem stores remaining time if interrupted
14
15// clock_nanosleep() — monotonic clock (not affected by clock adjustments)
16clock_nanosleep(CLOCK_MONOTONIC, 0, &req, &rem);

1// Thread.sleep() — millisecond resolution
2Thread.sleep(500);  // 500 ms
3
4// With nanosecond hint
5Thread.sleep(500, 250000);  // 500ms + 250µs
6
7// TimeUnit for clarity
8import java.util.concurrent.TimeUnit;
9TimeUnit.SECONDS.sleep(2);
10TimeUnit.MILLISECONDS.sleep(500);
11
12// Interruptible — throws InterruptedException
13try {
14    Thread.sleep(1000);
15} catch (InterruptedException e) {
16    Thread.currentThread().interrupt();  // Restore interrupt flag
17}

1// setTimeout — non-blocking (callback-based)
2setTimeout(() => {
3    console.log("After 500ms");
4}, 500);
5
6// Promise-based sleep for async/await
7function sleep(ms) {
8    return new Promise(resolve => setTimeout(resolve, ms));
9}
10
11async function main() {
12    console.log("Start");
13    await sleep(500);
14    console.log("After 500ms");
15}

1Timer Wheel (simplified):
2┌─────────────────────────────────────────────┐
3│ Slot 0 → [Thread A: expire at tick 100]     │
4│ Slot 1 → [Thread B: expire at tick 101]     │
5│ Slot 2 → (empty)                            │
6│ Slot 3 → [Thread C: expire at tick 103]     │
7│ ...                                         │
8│ Slot N → [Thread D: expire at tick N+100]   │
9└─────────────────────────────────────────────┘
10
11Each tick (e.g., 1ms):
12  1. Advance the wheel pointer
13  2. Expire all timers in the current slot
14  3. Move expired threads to the ready queue

1import time
2
3# Measure actual sleep duration
4start = time.perf_counter()
5time.sleep(0.01)  # Request 10ms
6elapsed = time.perf_counter() - start
7print(f"Requested: 10ms, Actual: {elapsed*1000:.2f}ms")
8# Typical output: Requested: 10ms, Actual: 10.47ms (Linux), 15.62ms (Windows)

1// Kernel sleep — yields CPU, efficient for long sleeps
2sleep(1);  // OS handles the wait, thread uses 0% CPU
3
4// Busy-wait — spins the CPU, used for sub-microsecond precision
5while (get_timestamp() < target_time) {
6    // CPU spins at 100% — wastes power but extremely precise
7}
8
9// Hybrid — sleep for most of the duration, then busy-wait for precision
10void precise_sleep(double seconds) {
11    double start = get_time();
12    double remaining = seconds;
13
14    // Kernel sleep for the bulk
15    if (remaining > 0.002) {  // > 2ms
16        nanosleep(remaining - 0.002);
17    }
18
19    // Busy-wait for the last ~2ms (high precision)
20    while (get_time() - start < seconds) {
21        // spin
22    }
23}

1# Python 3.11+ high-resolution sleep
2import time
3
4# time.sleep() uses the highest resolution available
5# On Linux: nanosleep() with CLOCK_MONOTONIC
6# On Windows: CreateWaitableTimerExW with HIGH_RESOLUTION (Python 3.11+)
7
8# For precise timing, use perf_counter
9start = time.perf_counter_ns()  # Nanosecond resolution
10time.sleep(0.001)
11elapsed_ns = time.perf_counter_ns() - start
12print(f"Elapsed: {elapsed_ns / 1e6:.2f}ms")