MultiThreading Models in Operating System | OS Tutorials

Multithreading models in the operating system – Threads are an inherent part of software products as a fundamental unit of CPU utilization, as a basic building block of multithreaded systems. The use of threads has evolved over the years from each program consisting of a single thread as the path of execution.

The notion of multithreading is the expansion of the original application thread to multiple threads, running in parallel, handling multiple events, and performing multiple tasks concurrently. Today’s modern operating systems foster the ability of multiple threads controlled by a single process, all within the same address space. Multithreading brings a higher level of responsiveness to the user, as a thread can run while other threads are on hold, awaiting instructions. As all threads are contained within a parent process, they share the resources and memory allocated to the process, working within the same address space, making it less costly to generate multiple threads.

These benefits increase even further when executed on a multiprocessor architecture, as multiple threads can run in parallel across multiple processors, while only one process may execute on one processor. Threads divide into two types:

• user-level threads – visible to developers but unknown to the kernel.
• kernel-level threads – managed by the operating system’s kernel.

Three models identify the relationships between user-level and kernel-level threads:

• one-to-one
• many-to-one
• many-to-many.

Multithreading Models in Operating System

Threads divide into two types: user threads and kernel threads. User threads are user-level threads handled independent from and above the kernel and thereby managed without any kernel support. On the other hand, the operating system directly manages the kernel threads. Nevertheless, there must be a form of relationship between user-level and kernel-level threads. There exist three established multithreading models, classifying these relationships as:

1. One-to-One Model,
2. Many-to-One Model,
3. Many-to-Many Model.

One-to-One Model

• The one-to-one model (Figure 1) associates a single user-level thread to a single kernel-level thread.
• This type of relationship facilitates the running of multiple threads in parallel.
• However, this benefit comes with its own drawback, such that the generation of every new user thread must include the creation of a corresponding kernel thread, causing an overhead, which can hinder the performance of the parent process.
• Windows series and Linux operating systems try to tackle this problem by limiting the growth of the thread count.

Many-to-One Model

• The many-to-one model (Figure 2) associates all user-level threads to a single kernel-level thread.
• This type of relationship facilitates an effective context-switching environment, easily implementable even on simple kernels with no thread support.
• The downside is that since there is only one kernel-level thread scheduled at any given time, this model cannot take advantage of the hardware acceleration offered by multi-threaded processors or multi-processor systems.

Many-to-Many Model

• The many-to-many model (Figure 3) is a compromise between the last two models.
• In this model, several user-level threads are associated with an equal or smaller number of kernel-level threads. The requirement of changing code in both kernel and user spaces presents a level of complexity not present in the previous models.
• Similar to the many-to-one model, this model presents an effective context-switching environment as it avoids system calls.
• The heightened complexity presents the potential for priority inversion and suboptimal scheduling with little coordination between the user and kernel schedulers.

Benefits of Multithreading Models

• Responsiveness: Multithreading allows a process to keep running even if some threads within the process are stalled, working on a lengthy task, or awaiting user interaction. Using a digital alarm clock as an example of a process, the thread of keeping track of time continues while an alarm is sounding, while another awaits its time to activate.
• Cost-Effective: Memory and resource allocation to process creation remains costly, whereas threads share the resources allocated to the process they reside in, making it less costly to create threads or move them from one process to another.
• Resource Distribution: The inherent property of sharing memory and resources of the parent process fosters the ability of having multiple threads occupying the same address space.
• Cross-Processor Distribution: The benefits of multithreading are multiplied as the number of available processors increases, opposite to single threading, where only one processor is used. In a multiprocessor architecture, the running of threads can be distributed across multiple processors in parallel, thereby increasing efficiency.