Introduction A thread is the smallest unit of CPU utilization within a process, comprising its own program counter, register set and stack space, but sharing the process’s code, data and OS resources. Threads enable parallelism and better resource utilization. Based on where threads are managed, they are classified into User-Level Threads (ULTs) and Kernel-Level Threads (KLTs).

1. User-Level Threads (ULT)

1. Definition & Implementation
   • Managed entirely in user space by a thread library (e.g., GNU Pth, POSIX pthreads in user-mode implementations).
   • The kernel is unaware of ULTs; it schedules only the containing process.
2. Thread Management
   • All thread operations—creation, synchronization, scheduling, context switching—are done through library calls (no system calls).
   • Fast operations: creation and switching involve only function calls, no kernel intervention.
3. Advantages
   • Low overhead: context switch in user space is microseconds.
   • Portability: library can be implemented on any OS without kernel changes.
   • Flexibility: application-specific scheduling policies.
4. Disadvantages
   • Blocking: if one thread issues a blocking system call, the entire process blocks (all ULTs blocked).
   • No true concurrency: on multiprocessors, ULTs cannot run in parallel since the kernel schedules only one “process” thread at a time.
   • Lacks kernel support: no preemptive scheduling by the OS; relies on cooperative yielding.

2. Kernel-Level Threads (KLT)

1. Definition & Implementation
   • Fully supported and managed by the OS kernel (e.g., Linux pthreads, Windows threads).
   • Threads are kernel entities—each has a kernel data structure (TCB).
2. Thread Management
   • Creation, scheduling, synchronization are system calls into the kernel (clone(), CreateThread()).
   • Kernel can schedule threads on different CPUs, enabling true parallelism.
3. Advantages
   • True concurrency: on multi-core systems, different KLTs of a process can execute simultaneously.
   • Non-blocking: if one thread blocks (I/O, page fault), the kernel can schedule another thread in the same process.
   • Kernel scheduling: supports priority-based, time-slice scheduling.
4. Disadvantages
   • Higher overhead: thread operations involve expensive system calls and mode switches.
   • Portability issues: behavior and API may vary across OS versions.
   • Scalability limits: large numbers of KLTs can tax kernel resources (memory for TCBs, scheduling tables).

3. Comparison