Download slide

Lecture 4: Threads
Operating System
Fall 2006
1
Contents






Overview: Processes & Threads
Benefits of Threads
Thread State and Operations
User Thread and Kernel Thread
Multithreading Models
Threading Issues
2
Process

Resource ownership




Scheduling/execution




process is allocated a virtual address space to hold the
process image
Process may be allocated control or ownership of resources,
e.g. I/O and files
Protection function by OS
The execution of a process follows an execution path(trace)
through one or more programs
The execution of a process may be interleaved with other
processes
Execution state and a dispatching priority
These two characteristics are treated independently
by the operating system
3
Processes & Threads


Resource ownership – Process or Task
Scheduling/execution – Thread or lightweight process
One process,
one thread (MS-DOS)
Multiple processes,
one thread per process (Unix)
One process,
multiple threads (Java Runtime)
Multiple processes,
multiple threads (W2K, Solaris, Linux)
4
Processes & Threads (cont.)

In a multithreaded environment, the followings are
associated with a process:



Address space to hold the process image
Protected access to processors, other processes (IPC), files,
and I/O resources (devices & channels)
Within a process, there may be one or more threads,
each with the following:





A thread execution state (Running, Ready, etc)
A saved context when not running – a separate program
counter
An execution stack
Some static storage for local variables for this thread
Access to memory and resources of its process, shared with
all other threads in that process (global variables)
5
Single Threaded and Multithreaded
Process Models
6
Benefits of Threads

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 use.
Resource Sharing

Since threads within the same process share
memory and files, they can communicate with
each other without invoking the kernel
7
Benefits of Threads (cont.)

Economy




Takes less time to create a new thread than a
process
Less time to terminate a thread than a process
Less time to switch between two threads within
the same process
Utilization of Multiprocessor Architectures

Threads within the same process may be running
in parallel on different processors
8
Uses of Threads in a SingleUser Multiprocessing System

Foreground and background work


Asynchronous processing


Asynchronous elements in the program can be implemented as threads. For
example, as a protection against power failure, a word processor may write
its buffer to disk once every minute. A thread can be created whose sole
job is periodic backup and that schedules directly with the OS.
Speed execution


For example, in a spreadsheet program, one thread could display menus
and read user input, while another thread executes user commands and
updates the spreadsheet.
On a multiprocessor system, multiple threads from the same process may
be able to execute simultaneously.
Modular program structure

Programs that involve a variety of activities or a variety of sources and
destinations of input and output may be easier to design and implement
using threads.
9
Thread States

Running
Ready
Blocked

Note: Suspend is at process-level


10
Thread Operations




Spawn – create new thread
Block – when a thread needs to wait for an
event, it will block
Unblock – when the event for which a thread
is blocked occurs, the thread is moved to the
ready queue.
Finish – when a thread completes, its register
context and stack are deallocated.
11
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
12
Question?

If one thread in a process is blocked,
does this prevent other threads in the
process even if that other thread is in a
ready state?
13
Answer

Depends on whether OS is involved
when the thread is blocked. If OS is
involved, then answer is “yes”.
14
Thread Synchronization


All of the threads of a process share the same
address space and other resources such as open
files. Any alternation of a resource by one thread
affects the environment of the other threads in the
same process. It is therefore necessary to
synchronize the activities of the various threads.
Will be covered later.
15
User Thread and Kernel Thread
16
User Threads





All of the work of thread management is done by the
application.
The kernel is not aware of the existence of threads
An application can be programmed to be multi-threaded by
using a threads library, which is a package of routines for user
thread management.
The thread library contains code for creating and destroying
threads, for passing messages and data between threads, for
scheduling thread execution and for saving and restoring thread
contexts.
Three primary thread libraries:



POSIX Pthreads
Win32 threads
Java threads
17
Pure User Threads

Advantages:




Thread switching does not require user/kernel mode
switching.
Thread scheduling can be application specific.
User Threads can run on any OS through a thread library.
Disadvantages:


When a ULT executes a system call, not only the thread is
blocked, but all of the threads within the process are
blocked.
Multithreaded application cannot take advantage of
multiprocessing since kernel assign one process to only one
processor at a time.
18
Kernel Threads



Supported and managed directly by the OS.
W2K, Linux, and OS/2 are examples of this
approach
In a pure Kernel Thread facility, all of the
work of thread management is done by the
kernel. There is no thread management code
in the application area, simply an application
programming interface to the kernel thread
facility.
19
Pure Kernel Threads

Advantages



Kernel can simultaneously schedule multiple
threads from the same process on multiple
processors
If one thread in a process is blocked, kernel can
schedule another thread of the same process
Disadvantage

More overhead
20
Multithreading Models

Many-to-One

One-to-One

Many-to-Many
21
Many-to-One


Many user-level threads
mapped to single kernel
thread
Examples:


Solaris Green Threads
GNU Portable Threads
22
One-to-One


Each user-level thread maps to kernel thread
Examples



Windows NT/XP/2000
Linux
Solaris 9 and later
23
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 NT/2000 with
the ThreadFiber package
24
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
25
Threading Issues






Semantics of fork() and exec()
system calls
Thread cancellation
Signal handling
Thread pools
Thread specific data
Scheduler activations
26
Semantics of fork() and exec()

Does fork() duplicate only the calling
thread or all threads?
27
Thread Cancellation


Terminating a thread before it has finished
Two general approaches:


Asynchronous cancellation terminates the
target thread immediately
Deferred cancellation allows the target thread to
periodically check if it should be cancelled
28
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.
2.
3.

Signal is generated by particular event
Signal is delivered to a process
Signal is handled
Options:




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
29
Thread Pools


Create a number of threads in a pool where they
await work
Advantages:


Usually slightly faster to service a request with an
existing thread than create a new thread
Allows the number of threads in the application(s) to be
bound to the size of the pool
30
Thread Specific Data


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)
31
Scheduler Activations



Both M:M and Two-level models require
communication to maintain the appropriate
number of kernel threads allocated to the
application
Scheduler activations provide upcalls - a
communication mechanism from the kernel to
the thread library
This communication allows an application to
maintain the correct number kernel threads
32
End of lecture 4
Thank you!
33