1
Topic 4: Threads
2
Contents
Overview: Processes & Threads
Benefits of Threads
Thread State and Operations
User Thread and Kernel Thread
Multithreading Models
Threading Issues
3
4.1 overview of process and
threads
Two characteristics of process:
Resource ownership
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
Scheduling/execution
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
modern operating systems
The unit of resource ownership is called Process or Task
The unit of Scheduling/execution is called thread or lightweight
process
4
Processes & Threads
Multithreading refers the ability of an OS t support
multiple threads of execution within a single process
One process,
one thread (MS
-
DOS)
One process,
multiple threads (Java Runtime)
Multiple processes,
multiple threads (W2K, Solaris, Linux)
Multiple processes,
one thread per process (Unix)
5
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)
6
Single and Multithreaded
Processes
7
Multi
-
Threading
Implementation
Each thread is described by a
thread
-
control block
(TCB)
A TCB typically contains
Thread ID
Space for saving registers
Pointer to thread
-
specific data not on stack
Observation
Although the model is that each thread has a private stack,
threads actually share the process address space
There’s no memory protection!
Threads could potentially write into each other’s stack
8
4.2 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
9
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
10
Uses of Threads in a Single
-
User Multiprocessing System
Foreground and background work
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.
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
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.
11
4.3 Thread States
Running
Ready
Blocked
Note: Suspend is at process
-
level
12
Diagram of Thread State
13
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.
14
4.4 User Thread and Kernel
Thread
15
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
16
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.
17
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.
18
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
19
4.5 Multithreading Models
Many
-
to
-
One
One
-
to
-
One
Many
-
to
-
Many
20
Many
-
to
-
One
Many user
-
level threads
mapped to single kernel
thread
Examples:
Solaris Green Threads
GNU Portable Threads
21
One
-
to
-
One
Each user
-
level thread maps to kernel thread
Examples
Windows NT/XP/2000
Linux
Solaris 9 and later
22
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
23
4.6 Threading Issues
Semantics of
fork()
and
exec()
system calls
Thread cancellation
Signal handling
Thread pools
Thread specific data
Scheduler activations
24
Semantics of fork() and exec()
Does
fork()
duplicate only the calling
thread or all threads?
25
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
26
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.
Signal is generated by particular event
2.
Signal is delivered to a process
3.
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
27
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
28
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)
29
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
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Comments 0
Log in to post a comment