Chapter 4: Threads &
Concurrency
Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
Objectives
To introduce the notion of a thread
To examine issues related to multithreaded programming
To cover operating system support for threads
Operating System Concepts – 10th Edition 4.2 Silberschatz, Galvin and Gagne ©2018
Concurrency and Parallelism
Operating System Concepts – 10th Edition 4.3 Silberschatz, Galvin and Gagne ©2018
Concurrency and Parallelism
Parallelism implies that a system can perform more than one task
simultaneously
Concurrency supports more than one task making progress
Single processor / core, scheduler providing concurrency
Multi-core or multiprocessor systems putting pressure on
programmers, challenges include:
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging
Operating System Concepts – 10th Edition 4.4 Silberschatz, Galvin and Gagne ©2018
Concurrency vs. Parallelism
Concurrent execution on single-core system:
Parallelism on a multi-core system:
Operating System Concepts – 10th Edition 4.5 Silberschatz, Galvin and Gagne ©2018
Types of 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
Operating System Concepts – 10th Edition 4.6 Silberschatz, Galvin and Gagne ©2018
Amdahl’s Law
Identifies performance gains from adding additional cores to an
application that has both serial and parallel components
S is serial portion
N processing cores
That is, if application is 75% parallel / 25% serial, moving from 1 to 2
cores results in speedup of 1.6 times
As N approaches infinity, speedup approaches 1 / S
Operating System Concepts – 10th Edition 4.7 Silberschatz, Galvin and Gagne ©2018
Introduction to Threads and
Multithreading
Operating System Concepts – 10th Edition 4.8 Silberschatz, Galvin and Gagne ©2018
What is a thread?
Traditional (single-threaded) process has a single thread of control.
A thread is a basic unit of CPU utilization
Also called a “lightweight process (LWP)” low creation overhead
The thread shares with other threads (belonging to the same process) its
code section, data section, and other OS resources, such as open files.
A process with multiple threads can do more than one task at a time.
What resources are used when a thread is created? How do they differ
from those used when a process is created?
What two advantages do threads have over multiple processes? What
major disadvantage do they have?
Operating System Concepts – 10th Edition 4.9 Silberschatz, Galvin and Gagne ©2018
Single and Multithreaded (MT)
Processes
Operating System Concepts – 10th Edition 4.10 Silberschatz, Galvin and Gagne ©2018
Examples of MT Applications
Web browser
Word processor
Web-server
Problem?
Two possible solutions
Suggest another application that would benefit from the use of threads,
and an application that would not.
Operating System Concepts – 10th Edition 4.11 Silberschatz, Galvin and Gagne ©2018
Benefits of MT Applications
Responsiveness – may allow continued execution if part of
process is blocked, especially important for user interfaces
Resource Sharing – threads share resources of process, easier
than shared memory or message passing
Economy – cheaper than process creation, thread switching
lower overhead than context switching
Scalability – process can take advantage of multiprocessor
architectures
Operating System Concepts – 10th Edition 4.12 Silberschatz, Galvin and Gagne ©2018
Multithreaded Server Architecture
Operating System Concepts – 10th Edition 4.13 Silberschatz, Galvin and Gagne ©2018
User Threads and Kernel Threads
Operating System Concepts – 10th Edition 4.14 Silberschatz, Galvin and Gagne ©2018
User Threads
Implemented by a thread library at the user level (above the kernel)
The library provides support for thread creation, scheduling, and
management.
The programmer of the library writes code to synchronize threads and to
context switch them, and they all run in one process.
Kernel does not provide any support; it is unaware that user-level
threads are even running.
Fast to create and manage (i.e., high efficiency), mainly because the
kernel is not involved.
What if the kernel is single-threaded?
Three primary thread libraries: POSIX Pthreads, Windows threads, Java
threads
Operating System Concepts – 10th Edition 4.15 Silberschatz, Galvin and Gagne ©2018
Kernel Threads
Supported directly by the OS
The kernel performs thread creation, scheduling, and management
in kernel space.
Slower to create and manage than user threads and have more
overhead in the kernel.
If a thread performs a blocking system call, the kernel can schedule
another thread in the application for execution.
In a parallel environment, the kernel can schedule threads on different
processors.
Examples – virtually all general-purpose OS’s, including Windows,
Solaris, Linux, Mac OS X
Operating System Concepts – 10th Edition 4.16 Silberschatz, Galvin and Gagne ©2018
Multithreading Models
Operating System Concepts – 10th Edition 4.17 Silberschatz, Galvin and Gagne ©2018
MT Models
Many-to-One
One-to-One
Many-to-Many
Operating System Concepts – 10th Edition 4.18 Silberschatz, Galvin and Gagne ©2018
Many-to-One MT
Many user-level threads mapped to
single kernel thread
One thread blocking causes all to block
Multiple threads may not run in parallel
on muti-core system because only one
may be in kernel at a time
Used in systems that do not support
kernel threads
Few systems currently use this model
Examples:
Solaris Green Threads
GNU Portable Threads
Operating System Concepts – 10th Edition 4.19 Silberschatz, Galvin and Gagne ©2018
One-to-One MT
Each user-level thread maps to kernel thread
Creating a user-level thread creates a kernel thread
More concurrency than many-to-one
allows a thread to run when another thread makes a blocking
system call
allows multiple threads to run in parallel on microprocessors
Examples:
Windows
Linux
Solaris 9 and later
Operating System Concepts – 10th Edition 4.20 Silberschatz, Galvin and Gagne ©2018
Many-to-Many MT
Allows many user-level threads to be
mapped to many kernel threads
Allows the operating system to create
a sufficient number of kernel threads
Addresses the limitations of one-to-
many and one-to-one models
Examples:
Solaris prior to version 9
Windows with the ThreadFiber
package
Operating System Concepts – 10th Edition 4.21 Silberschatz, Galvin and Gagne ©2018
Two-Level MT
Similar to many-to-many model, except that it allows a
user thread to be bound to kernel thread
Examples
IRIX
HP-UX
Tru64 UNIX
Solaris 8 and earlier
Operating System Concepts – 10th Edition 4.22 Silberschatz, Galvin and Gagne ©2018
MT Models: Summary
Many-to-one
The developer can create as many user threads as he wishes
But the true concurrency is not gained because the kernel can
schedule only one thread at a time
One-to-one
Greater concurrency than many-to-one
But the developer has to be careful (and in some instances be
limited) not to create too many threads within an application
Many-to-many
Does not suffer from the above shortcomings
Developers can create as many user threads as necessary, and the
corresponding kernel threads can run in parallel on a multiprocessor
Operating System Concepts – 10th Edition 4.23 Silberschatz, Galvin and Gagne ©2018
End of Chapter 4
Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
Multithreading Issues
Operating System Concepts – 10th Edition 4.25 Silberschatz, Galvin and Gagne ©2018
MT Issues
Signal handling
Synchronous and asynchronous
Thread cancellation of target thread
Asynchronous or deferred
Thread’s local storage
Scheduler Activations
Operating System Concepts – 10th Edition 4.26 Silberschatz, Galvin and Gagne ©2018
Signal Handling
Signals are used in UNIX systems to notify a process that a particular
event has occurred.
A signal handler is used to process signals
1. Signal is generated by particular event
2. Signal is delivered to a process
3. Signal is handled by one of two signal handlers:
1. default
2. user-defined
Every signal has default handler that kernel runs when handling signal
User-defined signal handler can override default
For single-threaded, signal delivered to process
Operating System Concepts – 10th Edition 4.27 Silberschatz, Galvin and Gagne ©2018
Signal Handling (Cont.)
Where should a signal be delivered for multi-threaded?
Deliver the signal to the thread to which the signal applies
Deliver the signal to every thread in the process
Deliver the signal to certain threads in the process
Assign a specific thread to receive all signals for the process
Operating System Concepts – 10th Edition 4.28 Silberschatz, Galvin and Gagne ©2018
Thread Cancellation
Terminating a thread before it has finished
Thread to be canceled is target thread
Two general approaches:
Asynchronous cancellation terminates the target thread
immediately
Deferred cancellation allows the target thread to periodically
check if it should be cancelled
Operating System Concepts – 10th Edition 4.29 Silberschatz, Galvin and Gagne ©2018
Thread Cancellation (Cont.)
Invoking thread cancellation requests cancellation, but actual
cancellation depends on thread state
If thread has cancellation disabled, cancellation remains pending until
thread enables it
On Linux systems, thread cancellation is handled through signals
Operating System Concepts – 10th Edition 4.30 Silberschatz, Galvin and Gagne ©2018
Thread’s Local Storage
Thread’s local storage (TLS) allows each thread to have its own copy
of data
Useful when you do not have control over the thread creation process
(i.e., when using a thread pool)
Different from local variables
Local variables visible only during single function invocation
TLS visible across function invocations
Operating System Concepts – 10th Edition 4.31 Silberschatz, Galvin and Gagne ©2018
Scheduler Activations
Both many-to-many and two-level models
require communication to maintain the
appropriate number of kernel threads allocated
to the application
Typically use an intermediate data structure
between user and kernel threads – lightweight
process (LWP)
Appears to be a virtual processor on which
process can schedule user thread to run
Each LWP attached to kernel thread
How many LWPs to create?
Scheduler activations provide upcalls - a
communication mechanism from the kernel to
the upcall handler in the thread library
This communication allows an application to
maintain the correct number kernel threads
Operating System Concepts – 10th Edition 4.32 Silberschatz, Galvin and Gagne ©2018
Operating System Examples
Windows Threads
Linux Threads
Operating System Concepts – 10th Edition 4.33 Silberschatz, Galvin and Gagne ©2018
Windows Threads
Windows implements the Windows API – primary API for Win
98, Win NT, Win 2000, Win XP, and Win 7
Implements the one-to-one mapping, kernel-level
Each thread contains
A thread id
Register set representing state of processor
Separate user and kernel stacks for when thread runs in
user mode or kernel mode
Private data storage area used by run-time libraries and
dynamic link libraries (DLLs)
The register set, stacks, and private storage area are known as
the context of the thread
Operating System Concepts – 10th Edition 4.34 Silberschatz, Galvin and Gagne ©2018
Windows Threads (Cont.)
The primary data structures of a thread include:
ETHREAD (executive thread block) – includes pointer to
process to which thread belongs and to KTHREAD, in
kernel space
KTHREAD (kernel thread block) – scheduling and
synchronization info, kernel-mode stack, pointer to TEB, in
kernel space
TEB (thread environment block) – thread id, user-mode
stack, thread-local storage, in user space
Operating System Concepts – 10th Edition 4.35 Silberschatz, Galvin and Gagne ©2018
Windows Threads Data Structures
Operating System Concepts – 10th Edition 4.36 Silberschatz, Galvin and Gagne ©2018
Linux Threads
Linux refers to them as tasks rather than threads
Thread creation is done through clone() system call
clone() allows a child task to share the address space of the
parent task (process)
Flags control behavior
struct task_struct points to process data structures
(shared or unique)
Operating System Concepts – 10th Edition 4.37 Silberschatz, Galvin and Gagne ©2018
