Operating Systems:
Internals and Design Principles, 6/E
William Stallings
Chapter 4
Threads
Patricia Roy
Manatee Community College, Venice, FL
2008, Prentice Hall
Processes and Threads
Resource ownership - process includes a
virtual address space to hold the process
image
Scheduling/execution- follows an
execution path that may be interleaved
with other processes
These two characteristics are treated
independently by the operating system
Processes and Threads
Dispatching is referred to as a thread or
lightweight process
Resource ownership is referred to as a
process or task
Multithreading
To support multiple, concurrent paths of
execution within a single process
Multithreading
MS-DOS supports a single user process
and thread
Some variants of UNIX support multiple
user processes but only one thread per
process
Java run-time environment is a single
process with multiple threads
Windows, Solaris, and other modern
versions of Unix support multiple processes
and multiple threads per process
Threads and Processes
Processes
A virtual address space which holds the
process image
Protected access to processors, other
processes (for interprocess
communication), files, and I/O resources
One or More Threads in
Process
An execution state (running, ready, etc.)
Saved thread context when not running
An execution stack
One or More Threads in
Process
Some per-thread static storage for local
variables
Access to the memory and resources of
its process
all threads of a process share this
Threads
Uses of Threads in a SingleUser Multiprocessing System
Modular program structure
Foreground and background work
One thread for user-interface, another for data
processing
Speed of execution
Asynchronous processing
For example, a thread to do backup for a
word processor
Remote Procedure Call Using
Single Thread
Download and display a web page in a
web browser
RPC Using One Thread per
Server
Benefits of Threads
Takes less time to create a new thread
than a process
Experiment shows that it is 10 times faster
Less time to terminate a thread than a
process
Less time to switch between two threads
within the same process
No memory reallocation is involved
Benefits of Threads
Since threads within the same process
share memory and files, they can
communicate with each other without
invoking the kernel
Threads
Suspending a process involves
suspending all threads of the process
since all threads share the same address
space
Termination of a process, terminates all
threads within the process
Thread States
States associated with a change in thread
state
Spawn
Spawn another thread
Block
Unblock
Finish
Deallocate register context and stacks
Thread Implementation - Packages
Threads are provided as a package,
including operations to create, destroy,
and synchronize them
A package can be implemented as:
User-level threads
Kernel threads
User-Level Threads
All thread management is done by the
application
The kernel is not aware of the existence of
threads
User-Level Threads
User-Level Threads
Thread library entirely executed in user mode
Kernel is not involved!
Cheap to manage threads
Create: setup a stack
Destroy: free up memory
Cheap to do context switch
Just save CPU registers
Done based on program logic
A blocking system call blocks all peer threads
Kernel-Level Threads
Kernel is aware of and schedules threads
A blocking system call, will not block all
peer threads
Windows is an example of this approach
Kernel maintains context information for
the process and the threads
Scheduling is done on a thread basis
Kernel-Level Threads
Kernel-Level Threads
Kernel is aware of and schedules threads
A blocking system call, will not block all
peer threads
More expensive to manage threads
More expensive to do context switch
Kernel intervention, mode switches are
required
Thread/Process Operation Latencies
processes
user-level threads
kernel-level threads
null fork
34 usec
948 usec
11,300 usec
signal-wait
37 usec
441 usec
1,840 usec
Operation
User vs. Kernel-Level Threads
Users-level threads
Cheap to manage and to do context switch
A blocking system call blocks all peer threads
Kernel-level threads
A blocking system call will not block all peer
threads
Expensive to manage and to do context switch
Light-Weight Processes (LWP)
Support for hybrid (user-level and kernel)
threads, example is Solaris
A process contains several LWPs
In addition, the system provides user-level
threads
Developer: creates multi-threaded
applications
System: Maps threads to LWPs for
execution
Thread Implementation LWP
Combining kernel-level lightweight processes and userlevel threads
Thread Implementation LWP
Each LWP offers a virtual CPU
LWPs are created by system calls
They all run the scheduler, to schedule
a thread
Thread table is kept in user space
Thread table is shard by all LWPs
LWPs switch context between threads
Thread Implementation LWP
When a thread blocks, LWP schedules
another ready thread
Thread context switch is completely done
in user mode
When a thread blocks on a system call,
execution mode changes from user to
kernel but continues in the context of the
current LWP
When current LWP can no longer
execute, context is switched to another
LWP
Thread Implementation LWP
Combining kernel-level lightweight processes and userlevel threads
LWP Features
Cheap thread management
A blocking system call may not suspend
the whole process
LWPs are transparent to the application
LWPs can be easily mapped to different
CPUs
Managing LWPs is expensive (like kernel
threads)
A Short Survey
On awareness of CSE Bits & Bytes
