Understanding CPU Time Slices, Hyper‑Threading, and Thread Context Switching

Time Slice

In multitasking systems, many jobs exceed the number of CPU cores, so the OS uses time‑slice round‑robin to give each task a short CPU slice, creating the illusion of simultaneous execution.

A time slice is the amount of CPU time allocated to each thread.

Thought: Why does a single‑core CPU also support multithreading?

Thread context includes registers and program counter; the CPU switches between threads rapidly, so a multi‑core CPU can reduce the frequency of context switches compared to a single core.

Hyper‑Threading

Modern CPUs contain cores, registers, caches, FPUs, and other auxiliary units. Multi‑core CPUs require threads to communicate across buses and handle cache coherence.

Hyper‑Threading, introduced by Intel, allows two logical threads to run concurrently on one core by adding a helper core; it increases die area by ~5% but can boost performance 15‑30%.

Context Switching

Thread switch: between two threads of the same process

Process switch: between two processes

Mode switch: between user and kernel mode within a thread

Address‑space switch: virtual to physical memory

During a switch the CPU saves the current task’s state and loads the next task’s state; this includes program counter, registers, and stack.

Registers are fast internal memory; the program counter points to the next instruction.

Problems of Thread Context Switching

Context switches add overhead, slowing high‑concurrency workloads; reducing switches improves multithreaded performance.

Direct cost: saving/loading registers, scheduler code, TLB reload, pipeline flush.

Indirect cost: cache sharing between cores, data size of thread worksets.

Viewing Switches

On Linux, the vmstat command shows the “cs” column, the number of context switches per second (typically <1500 on an idle system).

Thread Scheduling

Preemptive Scheduling

The OS controls how long each thread runs and when it is switched; Java threads are scheduled preemptively based on priority, but higher priority does not guarantee exclusive CPU time.

Cooperative Scheduling

Threads voluntarily yield the CPU after completing their work, similar to a relay race; if a thread blocks, the whole system can stall.

When a Thread Gives Up CPU

Thread calls yield() to voluntarily relinquish its time slice.

Thread blocks on I/O or other resources.

Thread finishes execution of its run() method.

Factors Triggering Context Switches

Time slice expiration.

Interrupt handling (hardware or software).

User‑mode switches.

Lock contention causing tasks to be preempted.

Optimization Techniques

Lock‑free concurrency (e.g., partition data by hash).

CAS algorithms via Java’s Atomic classes.

Use the minimal necessary number of threads.

Coroutines to achieve multitasking on a single thread.

Choosing an appropriate thread count maximizes CPU utilization while minimizing switching overhead; fewer threads for high‑concurrency low‑latency workloads, more threads for low‑concurrency high‑latency tasks, and a balanced approach for high‑concurrency high‑latency scenarios.