Threads (User vs Kernel Level)

A Thread is the basic unit of CPU utilization; it comprises a thread ID, a program counter, a register set, and a stack. It is sometimes called a lightweight process.

Traditional processes have a single thread of control. However, modern applications are heavily multithreaded. For example, a web browser might have one thread display images while another thread fetches data from the network.

1. Why use Threads instead of Processes?

If a web server used a heavy-weight process for every incoming request, it would consume massive amounts of memory and CPU cycles just creating and destroying those processes.

Threads within the same process share:

• The Code section (Text segment)
• The Data section (Global variables)
• OS resources (like open files and signals)

Because they share memory, threads are incredibly fast to create, fast to destroy, and extremely fast to switch between (context switching a thread is much cheaper than context switching a process).

2. User-Level Threads

User-level threads are implemented by a thread library at the user level, entirely independent of the operating system kernel. The kernel is completely unaware of these threads.

• Pros:
  • Extremely fast to create and manage because there is no kernel intervention (no expensive system calls required).
  • Can be implemented on an OS that doesn't natively support threads.
• Cons:
  • If a single user-level thread makes a blocking system call (like reading from disk), the kernel will block the entire process, freezing all other threads in that process.
  • Cannot take advantage of multiprocessor systems (all user threads map to a single kernel thread, which can only run on one CPU core at a time).

3. Kernel-Level Threads

Kernel-level threads are supported and managed directly by the operating system kernel. Windows, Linux, and macOS all use kernel-level threads.

• Pros:
  • If one thread performs a blocking system call, the kernel can simply schedule another thread in the application for execution.
  • True parallelism: The kernel can schedule different threads from the same process on different CPU cores simultaneously.
• Cons:
  • Thread creation and management are slower than user-level threads because they require system calls to the kernel.

4. Multithreading Models

How are user threads mapped to kernel threads?

1. Many-to-One Model: Maps many user-level threads to one kernel thread. Thread management is efficient, but if one thread blocks, the whole process blocks.
2. One-to-One Model: Maps each user thread to a kernel thread. Provides more concurrency, but creating a user thread requires creating the corresponding kernel thread, which adds overhead. (Standard in Linux and Windows).
3. Many-to-Many Model: Multiplexes many user-level threads to a smaller or equal number of kernel threads. Allows developers to create as many user threads as necessary without overloading the system with kernel threads.