Download slides

Chapter 4: Threads
Objectives
 Thread definitions and relationship to process
 Multithreading Models
 Threading Issues
 Some example thread libraries (Pthreads, Win32, Java)
Operating System Concepts
4.2
Silberschatz, Galvin and Gagne ©2005
Thread Definitions
 A thread is a basic unit of CPU utilization

A sequence of instructions enclosed in a function which CPU
can execute as a unit
 A process is a program in execution
 A process is composed of one or more threads
 Each thread is comprised of (from OS perspective)

Program counter

Register set, and
 Stack
 Threads belonging to the same process share
 Code section

Data section
 OS resources such as open files and signals
Operating System Concepts
4.3
Silberschatz, Galvin and Gagne ©2005
Single and Multithreaded Processes
Shared among threads
Operating System Concepts
4.4
Silberschatz, Galvin and Gagne ©2005
Why Multithreading?
 Example multithreaded applications

Web browsers: parallel downloads

Web servers: handle multiple concurrent clients

Word processors: spell check in the background

…. Many others …
 Why multithreading?

Responsiveness: one thread for GUI and another for
processing

Resource Sharing: similar requests handled by the same code
and use same files/resources

Economy: threads are much cheaper to create/delete than
processes

Utilization of multiprocessors: single threaded-process can
NOT make use of multiple processors
Operating System Concepts
4.5
Silberschatz, Galvin and Gagne ©2005
Multithreading Models
 Threads can be created and managed at two levels:


User level threads

All data structures are maintained in the user level

All thread operations are performed in user mode

Kernel knows nothing about user-level threads

Provided by user-level libraries
Kernel level threads

All data structures are maintained in the kernel space 

All thread operations have to be in kernel mode (need
system calls to perform them)

Provided by the OS (kernel)
–
Operating System Concepts
Most modern OSs (e.g., XP, Linux, MaC OS X, Solaris)
are multithreaded
4.6
Silberschatz, Galvin and Gagne ©2005
Multithreading Models (cont’d)
 In multithreaded kernels (i.e., most current OSs), mapping from
user-level threads to kernel-level threads can be:

Many-to-One

One-to-One

Many-to-Many
Operating System Concepts
4.7
Silberschatz, Galvin and Gagne ©2005
Many-to-One
 Many user-level threads mapped to
single kernel thread
 Thread management (create,
delete, schedule, …) is done in
user level
 Pros

Managing user threads are
faster (no system calls, no
need to switch to kernel mode)
 Cons
 One thread blocks, the entire
process blocks

Can not use multiprocessors
 Examples (Libraries)

Solaris Green Threads
 GNU Portable Threads
Operating System Concepts
4.8
Silberschatz, Galvin and Gagne ©2005
One-to-One
 Each user-level thread maps to a kernel thread
 Pros

Increased concurrency (can use multiprocessors)

A thread blocks, others can run
 Cons

Creating too many kernel threads may degrade performance
because they consume OS resources  may put limit on
number of threads a user can create
 Examples: Windows NT/XP/2000, Linux, Solaris 9 and later
Operating System Concepts
4.9
Silberschatz, Galvin and Gagne ©2005
Many-to-Many Model




Multiple user threads are mapped to
multiple kernel threads
 Mapping is NOT fixed, need thread
scheduler (in user level)
 OS support: a user thread blocks,
kernel notifies thread scheduler
(upcall) to select another to use the
free kernel thread
Pros
 Increased Concurrency
 Flexible: user may create as many user
threads as she wants, and kernel
creates only a sufficient number of
kernel threads
Cons
 Complex to implement
Examples:
 Solaris prior to version 9
 Windows NT/2000 with the
ThreadFiber package
Operating System Concepts
4.10
Silberschatz, Galvin and Gagne ©2005
Two-level Model
 Similar to Many-to-Many, except that
it allows a user thread to be bound
to kernel thread

Bound thread can be used for
critical operations or could be
the thread scheduler
 Examples

IRIX

HP-UX

Tru64 UNIX

Solaris 8 and earlier
Operating System Concepts
4.11
Silberschatz, Galvin and Gagne ©2005
Some Threading Issues
 Semantics of fork() and exec() system calls
 Signal handling
 Thread pools
Operating System Concepts
4.12
Silberschatz, Galvin and Gagne ©2005
Semantics of fork() within threads
 A process has multiple thread. One of them called fork().
 Should fork() duplicate only the calling thread or all threads (entire
process)?
 It depends:

If exec() is called immediately after fork(), no need to duplicate
all threads (they will be overwritten anyway)

Else, all threads should be duplicated
Operating System Concepts
4.13
Silberschatz, Galvin and Gagne ©2005
Signal Handling

Signals are used in UNIX to notify a process that an event has occurred

Sequence:
1.
Signal is generated by an event
2.
Signal is delivered to a process
3.
Signal handler processes the signal (default by OS, or user-defined)

See example code in the textbook

Should OS deliver a signal to: all threads, one thread, or specific thread of a
process?

It depends on the signal type

Synchronous: a thread performed an operation that caused a signal to
be generated (division by 0, illegal mem. access)


Deliver signal to the thread
Asynchronous: external event generated to the signal (ctrl–c )

Operating System Concepts
Deliver signal to all threads belonging to the process
4.14
Silberschatz, Galvin and Gagne ©2005
Thread Pools
 Create a number of threads in a pool where they await work

E.g., web server serving many requests of the same page
 Advantages

Usually faster to service a request with an existing thread
than create a new one

Limit number of threads in an application to pool size

Operating System Concepts
Further requests are queued till a thread is free 
important to maintain performance
4.15
Silberschatz, Galvin and Gagne ©2005
Example Thread Libraries
 POSIX Threads (Pthreads library)

API specifications, implementation is up to the OS

Common in UNIX systems: Solaris, Linux, Mac OS X
 Win 32 Threads

Implementation of the one-to-one model in kernel
 Java

Java threads are managed by JVM, which is run on top of an OS

JVM specifies the interface, does NOT dictate the implementation

JVM uses thread services provided by the host OS
Operating System Concepts
4.16
Silberschatz, Galvin and Gagne ©2005
A Note on Linux Threads
 Linux refers to threads and processes as tasks
 Thread creation is done through clone() system call
 clone() can be parameterized to allow a range of resource sharing
possibilities:

No sharing of resources between parent and child, the entire
process is duplicated (same as fork())

Sharing of all resources between parent and child

Only pointers to shared resources are created for child
 Linux does not differentiate between process and thread (both are
tasks). Is this good or bad?

Good: simplify scheduling

Bad: complex to correlate threads with their processes
Operating System Concepts
4.17
Silberschatz, Galvin and Gagne ©2005
Summary
 A thread is a basic unit of CPU utilization, a process is composed of
one or more threads
 Each thread has: Program counter, stack, registers
 Threads share: code, data, OS resources (open files and signals)
 User level threads vs. kernel threads
 Several mapping models from user threads to kernel threads

M-to-1, 1-to-1, M-to-M
 Thread issues: fork(), signals, thread pools, scheduler activation
 Thread libraries: Pthreads, Win32, Java
Operating System Concepts
4.18
Silberschatz, Galvin and Gagne ©2005