How Time Slices, Hyper‑Threading, and Context Switching Enable Multithreading

Time Slice

Because most computers now have multi‑core CPUs, multithreading can achieve higher concurrency, but creating too many threads adds overhead; the operating system solves this by allocating a short time slice to each thread, repeatedly switching between them.

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

Hyper‑Threading

Intel introduced Hyper‑Threading to allow two logical threads to run concurrently on one physical core. By adding a small auxiliary core, the CPU area grows about 5% while performance can improve 15%–30%.

Context Switching

Thread switch – between two threads of the same process

Process switch – between two processes

Mode switch – between user mode and kernel mode within a thread

Address‑space switch – swapping virtual memory to physical memory

Before switching, the CPU saves the current task’s state (registers, program counter, stack) to memory, then loads the next task’s state and resumes execution. Registers are fast internal memory, while the program counter indicates the next instruction address.

Suspend the current task and store its context in memory

Restore a task by loading its saved context back into the CPU registers

Jump to the address indicated by the program counter to continue execution

Problems of Context Switching

Context switches incur extra overhead, often making high‑concurrency workloads slower than serial execution.

Direct cost: saving/loading CPU registers, executing scheduler code, reloading TLB entries, flushing the CPU pipeline

Indirect cost: cache sharing between cores and the impact of data size on performance

Viewing Switches

On Linux, the vmstat command shows the number of context switches per second in the “cs” column; an idle system typically stays below 1500 cs/s.

Thread Scheduling

Preemptive Scheduling

The operating system decides how long each thread runs and when to switch; threads receive equal or priority‑based time slices, and a blocked thread does not block the whole process.

Java uses preemptive scheduling: threads are assigned CPU time based on priority, but higher priority does not guarantee exclusive use of the time slice.

Cooperative Scheduling

Threads voluntarily yield control after completing their work, similar to a relay race; this avoids unpredictable switches but can cause the entire system to stall if a thread deadlocks.

When a Thread Gives Up the CPU

The running thread voluntarily yields, e.g., by calling yield().

The thread becomes blocked, for example waiting on I/O.

The thread finishes execution, returning from its run() method.

Factors That Trigger Context Switches

Time slice expiration for the current thread.

Interrupt handling (hardware or software), such as I/O blocking or resource contention.

User‑mode switches performed by some operating systems.

Multiple tasks competing for locked resources, causing the CPU to alternate between programs.

Optimization Measures

Lock‑free concurrent programming (e.g., partition data by hash and let each thread handle a segment).

Use CAS (compare‑and‑swap) via Java’s Atomic classes instead of locks.

Minimize the number of threads.

Adopt coroutines to achieve multitasking within a single thread.

Setting an appropriate thread count maximizes CPU utilization while reducing the overhead of context switching. For high‑concurrency, low‑latency workloads, use fewer threads; for low‑concurrency, high‑latency tasks, increase the thread count; and for high‑concurrency, high‑latency scenarios, analyze task characteristics and adjust queueing and thread numbers accordingly.