Transcript Figure 5.01

Chapter 5: Threads
 Overview
 Multithreading Models
 Threading Issues
 Pthreads
 Solaris 2 Threads
 Windows 2000 Threads
 Linux Threads
 Java Threads
Operating System Concepts
5.1
Silberschatz, Galvin and Gagne 2002
Thread vs. Process
 A thread – lightweight process (LWP) is a basic unit of
CPU utilization.
 It comprises a thread ID, a program counter, a register
set, and a stack.
 A traditional (heavyweight) process has a single thread
of control.
 If the process has multiple threads of control, it can do
more than one task at a time.
Operating System Concepts
5.2
Silberschatz, Galvin and Gagne 2002
Single and Multithreaded Processes
Operating System Concepts
5.3
Silberschatz, Galvin and Gagne 2002
Motivation
 An application typically is implemented as a separate
process with several threads of control.
 For example, a web browser might have one thread
display images or text while another thread retrieves data
from the network.
 It is more efficient for a process that contains multiple
threads to serve the same purpose.
 This approach would multithread the web-server process.
Operating System Concepts
5.4
Silberschatz, Galvin and Gagne 2002
Benefits
 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.
 Economy: Allocating memory and resources for process
creation is costly.
 Utilization of MP (multiprocessor) Architectures: Each
thread may be running in parallel on a different processor.
Operating System Concepts
5.5
Silberschatz, Galvin and Gagne 2002
User Threads
 Thread management done by user-level threads library
 User-level threads are fast to create and manage.
 If the kernel is single-threaded, then any user-level thread
performing a blocking system call will cause the entire
process to block.
 Examples
- POSIX Pthreads
- Mach C-threads
- Solaris UI-threads
Operating System Concepts
5.6
Silberschatz, Galvin and Gagne 2002
Kernel Threads
 Supported by the Kernel: The kernel performs thread
creation, scheduling, and management in kernel space.
 Examples
- Windows 95/98/NT/2000
- Solaris
- Tru64 UNIX
- BeOS
- OpenBSD
- FreeBSD
- Linux
Operating System Concepts
5.7
Silberschatz, Galvin and Gagne 2002
Multithreading Models
 Many-to-One: The many-to-one model maps many user-
level threads to one kernel thread.
 One-to-One: The one-to-one model maps each user
thread to a kernel thread.
 Many-to-Many: The many-to-many multiplexes many
user-level threads to a smaller or equal number of kernel
threads.
Operating System Concepts
5.8
Silberschatz, Galvin and Gagne 2002
Many-to-One
 Many user-level threads mapped to single kernel thread.
 Used on systems that do not support kernel threads.
Operating System Concepts
5.9
Silberschatz, Galvin and Gagne 2002
Many-to-One Model
Operating System Concepts
5.10
Silberschatz, Galvin and Gagne 2002
One-to-One
 Each user-level thread maps to kernel thread.
 Examples
- Windows 95/98/NT/2000
- OS/2
Operating System Concepts
5.11
Silberschatz, Galvin and Gagne 2002
One-to-one Model
Operating System Concepts
5.12
Silberschatz, Galvin and Gagne 2002
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 2
 Windows NT/2000 with the ThreadFiber package
Operating System Concepts
5.13
Silberschatz, Galvin and Gagne 2002
Many-to-Many Model
Operating System Concepts
5.14
Silberschatz, Galvin and Gagne 2002
Multithreading Models - Conclusion
 Whereas the many-to-one model allows the developer to
create as many user threads as she wishes, true
concurrency is not gained because the kernel can
schedule only one thread at a time.
 The one-to-one model allows for 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: Developer 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.
Operating System Concepts
5.15
Silberschatz, Galvin and Gagne 2002
Threading Issues
 Semantics of fork() and exec() system calls: Two versions
of fork are one that duplicates all threads and another that
duplicates only the thread that invoked the fork system
call.
 Thread cancellation is the task of terminating a thread
before it has completed.
•
Two different scenarios are asynchronous cancellation and
deferred cancellation.
• A thread checks if it should be cancelled at a point referred
as cancellation point.
 Signal handling
 Thread pools
 Thread specific data is a copy of data owned by a thread.
Operating System Concepts
5.16
Silberschatz, Galvin and Gagne 2002
Signal Handling
 A signal is used in UNIX systems to notify a process that
a particular event has occurred.
 All signals follow the same pattern:
1. A signal is generated by the occurrence of a particular
event.
2. A generated signal is delivered to a process.
3. Once delivered, the signal must be handled.
 A signal can be synchronous or asynchronous:
• Synchronous signals are delivered to the same process.
• Asynchronous signal is generated by an external event.
Operating System Concepts
5.17
Silberschatz, Galvin and Gagne 2002
Signal Handling
 Every signal may be handled by one of two possible
handlers:
•
•
A default signal handler
A user-defined signal handler
 The options exist for delivering signals to a multithreaded
program:
1. Deliver the signal to the thread to which the signal applies.
2. Deliver the signal to every thread in the process.
3. Deliver the signal to certain threads in the process.
4. Assign a specific thread to receive all signals for the
process.
 Windows 2000 uses asynchronous procedure calls
(APCs) to emulate signals.
Operating System Concepts
5.18
Silberschatz, Galvin and Gagne 2002
Thread Pools
 A multithread server has potential problems:
• The time required includes thread creating and discarding.
• Unlimited threads could exhaust system resources.
 One solution to this issue is to use thread pools.
 A thread pool has a number of threads being created at
process startup, where they sit and wait for work.
 The benefits of thread pools are:
•
•
Operating System Concepts
It is usually faster to service a request with an existing
thread.
A thread pool limits the number of threads at any one point.
5.19
Silberschatz, Galvin and Gagne 2002
Thread-Specific Data
 A multithread server has potential problems:
• The time required includes thread creating and discarding.
• Unlimited threads could exhaust system resources.
 One solution to this issue is to use thread pools.
 A thread pool has a number of threads being created at
process startup, where they sit and wait for work.
 The benefits of thread pools are:
•
•
Operating System Concepts
It is usually faster to service a request with an existing
thread.
A thread pool limits the number of threads at any one point.
5.20
Silberschatz, Galvin and Gagne 2002
Pthreads
 a POSIX standard (IEEE 1003.1c) API for thread creation
and synchronization.
 API specifies behavior of the thread library,
implementation is up to development of the library.
 Common in UNIX operating systems.
 Refer to the program shown in Figure 5.5.
Operating System Concepts
5.21
Silberschatz, Galvin and Gagne 2002
Solaris 2 Threads
 Solaris 2 is a version of UNIX with support for threads at




the kernel and user levels, SMP, and real-time
scheduling.
Solaris 2 implements the Pthread API and UI threads.
Between user- and kernel-level threads are ligthweight
processes (LWPs).
Threads in a process multiplex to connect an LWP. An
LWP corresponds a kernel thread.
A (un)bound user-level thread is (not) permanently
attached to an LWP.
Operating System Concepts
5.22
Silberschatz, Galvin and Gagne 2002
Solaris 2 Threads
Operating System Concepts
5.23
Silberschatz, Galvin and Gagne 2002
Solaris Process
Operating System Concepts
5.24
Silberschatz, Galvin and Gagne 2002
Windows 2000 Threads
 Implements the one-to-one mapping.
 Each thread contains
- a thread id
- register set
- separate user and kernel stacks
- private data storage area
Operating System Concepts
5.25
Silberschatz, Galvin and Gagne 2002
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)
Operating System Concepts
5.26
Silberschatz, Galvin and Gagne 2002
Java Threads
 Java threads may be created by:
 Extending Thread class
 Implementing the Runnable interface
 Calling the start method for the new object does two
things:
1. It allocates memory and initializes a new thread in the JVM.
2. It calls the run method, making the thread eligible to be run
by JVM.
 Java threads are managed by the JVM.
Operating System Concepts
5.27
Silberschatz, Galvin and Gagne 2002
Java Thread States
Operating System Concepts
5.28
Silberschatz, Galvin and Gagne 2002