Chapter 4 Threads

Chapter 4: Threads
Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013
Chapter 4: Threads
Overview
Multicore Programming
Multithreading Models
Thread Libraries
Operating System Concepts – 9th Edition 4.2 Silberschatz, Galvin and Gagne ©2013
Objectives
To introduce the notion of a thread—a fundamental unit of CPU
utilization that forms the basis of multithreaded computer
systems
To discuss the APIs for the Pthreads, Windows, and Java
thread libraries
Terminology
Multiprogramming
A computer running more than one program at a time (like running
Excel and Firefox simultaneously)
Context switching
Multiprocessing
A computer using more than one CPU (processor) or core at a time▪
Multitasking
Multitasking is a logical extension of multi programming (time
sharing)
Tasks sharing a common resource (like 1 CPU)
Multithreading
Thread (a code segments)
is an extension of multitasking
Motivation
Most modern applications are multithreaded
Example:
 Web browser: one thread displays images or text while another thread
receives data from the network
 Word processor: a thread for displaying the graphics, another one for
responding to keystrokes, and a third thread for performing spelling and
grammar checking.
Threads run within application
Multiple tasks with the application can be implemented by separate
threads
Update display
Fetch data
Spell checking
Answer a network request
Process creation is heavy-weight while thread creation is light-weight
Can simplify code, increase efficiency
Kernels are generally multithreaded
Two Process Characteristics
Two process characteristics are treated independently by the operating
system
The unit of execution (CPU utilization) is referred to as a thread or
lightweight process.
The unit of resource ownership is referred to as a process or task.
Two process characteristics:
Resource Ownership Scheduling/Execution

Process includes a virtual Follows an execution path
address space to hold the that may be interleaved with
process image other processes
o The OS performs a protection o A process has an execution

function to prevent unwanted state (Running, Ready, etc.)
interference between processes and a dispatching priority, and
with respect to resources is the entity that is scheduled
and dispatched by the OS
One or More Threads in a Process
Each thread has:
An execution state (Running, Ready, etc.)
A saved thread context when not running
An execution stack
Some per-thread static storage for local variables
Access to the memory and resources of its processes, shared with all other
threads in that process.
Single and Multithreaded Processes
Two Process Characteristics
A single thread of execution per = instruction trace
process, in which the concept of a
thread is not recognized, is
referred to as a single-threaded
approach
o MS-DOS is an example
one processes one processes
one thread multiple threads
The right half of Figure 4.1 depicts
multithreaded approaches
A Java run-time environment is an
example of a system of one
process with multiple threads
multiple processes multiple processes

one thread per process multiple thread per process
Figure 4.1 Threads and Processes
Key Benefits of Threads
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
Multicore Programming
Multicore or multiprocessor systems putting pressure on

programmers, challenges include:
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging
Parallelism implies a system can perform more than one task
simultaneously
Concurrency supports more than one task making progress
Single processor / core, scheduler providing concurrency
Concurrency vs. Parallelism
Concurrent execution on single-core system:
Parallelism on a multi-core system:
Multicore Programming (Cont.)
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
As # of threads grows, so does architectural support for threading
CPUs have cores as well as hardware threads
Consider Oracle SPARC T4 with 8 cores, and 8 hardware
threads per core
Data and Task parallelism
Threads Implementation
User Level Thread (ULT)

Kernel Level Thread (KLT) also called:
o Kernel-supported thread
o Lightweight process
User Threads and Kernel Threads
User threads - management done by user-level threads library
o The user library contains code for creating threads, destroying threads,
scheduling thread execution and …
o The kernel is not aware of the existence of threads
Three primary thread libraries:
POSIX Pthreads
Windows threads
Java threads
Kernel threads - Supported by the Kernel
o There is no thread management code in the application level, simply an
application programming interface (API) to the kernel thread facility
o The kernel maintains context information for the process and threads
Examples – virtually all general purpose operating systems, including:
Windows Linux
Solaris Tru64 UNIX
Mac OS X
Advantages of ULTs and KLTs
Advantages of User Level Threads(ULTs)
Scheduling can be application specific and specify by programmer
ULTs can run on any OS, even the ones that do not support
multithreading like embedded OSs.
Less overhead: Thread switching does not require kernel mode
privileges
Advantages of Kernel Level Threads(KLTs)
The kernel can simultaneously schedule multiple threads from the
same process on multiple processors
If one thread in a process is blocked, the kernel can schedule
another thread of the same process
Kernel routines themselves can be multithreaded (in all modern
OSs)
Disadvantages of ULTs and KLTs
Disadvantages of User Level Threads(ULTs)
In a typical OS many system calls are blocking
As a result, when a ULT executes a system call, not only is that
thread blocked, but all of the threads within the process are blocked
as well
In a pure ULT strategy, a multithreaded application cannot take
advantage of multiprocessing
A kernel assigns one process to only one processor at a time,
therefore, only a single thread within a process can execute at a
time
Disadvantage of Kernel Level Threads(KLTs)
The transfer of control from one thread to another within the same
process requires a mode switch to the kernel (increase overhead for
OS
Multithreading Models
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 muticore system because only one
may be in kernel at a time
Few systems currently use this model
Examples:
Solaris Green Threads
GNU Portable Threads
One-to-One
Each user-level thread maps to kernel thread
Creating a user-level thread creates a kernel thread
More concurrency than many-to-one
Number of threads per process sometimes
restricted due to overhead
Examples
Windows
Linux
Solaris 9 and later
Ex: Multithreaded Server Architecture
Many-to-Many Model
Allows many user level threads to be
mapped to many kernel threads
Allows the operating system to create
a sufficient number of kernel threads
Solaris prior to version 9
Windows with the ThreadFiber
package
Two-level Model
Similar to M:M, except that it allows a user thread to be

bound to kernel thread
Examples
IRIX
HP-UX
Tru64 UNIX
Solaris 8 and earlier
Thread Libraries
Thread library provides programmer with API for creating

and managing threads
Two primary ways of implementing
Library entirely in user space
Kernel-level library supported by the OS
Pthreads
May be provided either as user-level or kernel-level

A POSIX standard (IEEE 1003.1c) API for thread creation and
synchronization
Specification, not implementation
API specifies behavior of the thread library, implementation is
up to development of the library
Common in UNIX operating systems (Solaris, Linux, Mac OS X)
Pthreads Example
Pthreads Example (Cont.)
Pthreads Code for Joining 10 Threads
Windows Multithreaded C Program
Windows Multithreaded C Program (Cont.)
Java Threads
Java threads are managed by the JVM

Typically implemented using the threads model provided by
underlying OS
Java threads may be created by:
Extending Thread class

Implementing the Runnable interface
Java Multithreaded Program
End of Chapter 4
Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013

Chapter 4 Threads

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 4 Threads

Uploaded by

Copyright:

Available Formats

Chapter 4: Threads

Resource Ownership Scheduling/Execution

o The OS performs a protection o A process has an execution

multiple processes multiple processes

Figure 4.1 Threads and Processes

Responsiveness – may allow continued execution if part of

Multicore or multiprocessor systems putting pressure on

Parallelism on a multi-core system:

User Level Thread (ULT)

Many user-level threads mapped to

Similar to M:M, except that it allows a user thread to be

Thread library provides programmer with API for creating

May be provided either as user-level or kernel-level

Java threads are managed by the JVM

Extending Thread class

You might also like