Multithreading
0 likes1 view
Multithreading allows a process to have multiple threads that can perform tasks simultaneously. A word processor for example may have one thread for displaying graphics, another for responding to keystrokes, and a third for spell checking in the background. There are three main multithreading models: many-to-one maps many user threads to one kernel thread but blocks if a thread makes a blocking system call; one-to-one maps each user thread to a kernel thread allowing more concurrency; many-to-many multiplexes user threads to kernel threads allowing developers to create many user threads and kernel threads to run in parallel without blocking.
Multithreading
- 1. Multithreading When there are more than one thread is known as multithreading. A process can have multiple threads means multiple tasks can be performed at the same time. A word processor may have a thread for displaying graphics, another thread for responding to keystrokes from the user, and a third thread for performing spelling and grammar checking in the background. The operating system in which the multithreading is used Windows NT 4.0 Windows 95 Windows 98 Windows 2000 Advantages of Multithreading Responsiveness. Multithreading an interactive application may allow a program to continue running even if part of it is blocked or is performing a lengthy operation, thereby increasing responsiveness to the user. Resource sharing. Threads share the memory and the resources of the process to which they belong by default. Economy. Allocating memory and resources for process creation is costly. Because threads share the resources of the process to which they belong, it is more economical to create and context- switch threads. Scalability. The benefits of multithreading can be even greater in a multiprocessor architecture, where threads may be running in parallel on different processing cores. Multithreading Models Many-to-One Model The many-to-one model (Figure 4.5) maps many user-level threads to one kernel thread. Thread management is done by the thread library in user space, so it is efficient (we discuss thread libraries in Section 4.4). However, the entire process will block if a thread makes a blocking system call. Also, because only one thread can access the kernel at a time, multiple threads are unable to run. Solaris systems and adopted in early versions of Java—used the many-to-one model.
- 2. One-to-One Model The one-to-one model (Figure 4.6) maps each user thread to a kernel thread. It provides more concurrency than the many-to-one model by allowing another thread to run when a thread makes a blocking system call. It also allows multiple threads to run in parallel on multiprocessors. The only drawback to this model is that creating a user thread requires creating the corresponding kernel thread. Many-to-Many Model The many-to-many model (Figure 4.7) multiplexes many user-level threads to a smaller or equal number of kernel threads. Let’s consider the effect of this design on concurrency. Whereas the many-to- one model allows the developer to create as many user threads as she wishes, it does not result in true concurrency, because the kernel can schedule only one thread at a time. The one-to- one model allows greater concurrency, but the developer has to be careful not to create too many threads within an application The many-to-many model suffers from neither of these shortcomings: developers can create as many user threads as necessary, and the corresponding kernel threads can run in parallel on a multiprocessor. Also, when a thread performs a blocking system call, the kernel can schedule another thread for execution.