Thread : One process, but more than one point of execution, multiple program counters
Threads share address space (code, data), one pagetable .
Each thread has own state, PC and registers, scheduled, context switch, own stack (thread-local storage), threadcontrolblock (TCB)
Thread Control Block (TCB) contains:
TID
Thread State
PC and Registers
Stack
Parallelization : A single-threaded program to multiple threads, each on one CPU.
Most modern applications are multithreaded
Threads run within application
Multiple tasks with the application can be implemented by separatethreads :
Update display, Fetch data, Spell checking, Answer a network request
Multiple processes vs a process with multiple threads :
Process creation is heavy-weight while thread creation is light-weight Can simplify code, increase efficiency
Kernels are generally multithreaded
This is an example of MultithreadedServerArchitecture :
Parallelism implies a system can perform more than one task simultaneously
Concurrency supports more than one task making progress
Types of Parallelism:
Data Parallelism
Task Parallelism
Data parallelism – distributes subsets of the same data across multiple cores, same operation on each
Task parallelism – distributing threads across cores, each thread performing unique operation
This is an example of Data Parallelism :
This is an example of Task Parallelism :
Benefits of Parallelism:
Responsiveness
Resource Sharing
Economy
Scalability
User threads - management done by user-level threads library
Three primary thread libraries:
POSIX Pthreads
Windows threads
Java threads
Kernel threads - Supported by the Kernel
virtually all general purpose operating systems, including Windows, Linux, Mac OS X, iOS, Android are all examples of kernel threads
Multithreading Models:
Many to One
One to One
Many to Many
Many to One :
Many user-level threads mapped to single kernel thread
One thread blocking causes all to block Multiple threads may not run in parallel on multicore system because only one may be in kernel at a time
This is an example of a Many to One Thread Model:
Solaris Green Threads and GNU Portable Threads are examples of a Many to One thread model.
One to One :
Each user-level thread maps to the kernel thread
Creating a user-level thread creates a kernel thread
More concurrency than many-to-one
The number of threads per process is sometimes restricted due to overhead
Windows and Linux are examples of One to One thread models
This is an example of a One to One thread model:
Many to Many :
Allows many user level threads to be mapped to many kernel threads Allows the operating system to create a sufficient number of kernel threads
This is an example of a Many to Many thread model :
Two level model : Similar to M:M, except that it allows a user thread to be bound to kernel thread
This is an example of a Two Level thread model :
Thread library provides programmer with API for creating and managing threads
Two primary ways of implementing thread libraries :
Library entirely in user space
Kernel-level library supported by the OS
Pthreads may be provided either as user-level or kernel-level
Multiple threads within a process _ .
Will always execute the same sequence of instructions
Must execute within disjoint parts of the shared program
May execute different sequences of instructions within any part of the shared program. Answer: 3
Using n threads within a single process is more efficient than using n separate processes because the threads share the same code and data (T or F)
T
Using n threads within a single process is more efficient than using n separate processes because only the threads can take advantage of multiple CPUs (T or F)