Chapter 4: Threads

Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013
 Chapter 4: Threads
● Overview
● Multithreading Models
● Threading Issues

Operating System Concepts – 9th Edition 4.2 Silberschatz, Galvin and Gagne ©2013
 overview

A thread is a basic unit of CPU utilisation.

It has-thread ID, PC, register ,stack.
It shares with other threads belonging to the same process its code section, data
section and open files
If a process has multiple threads of control,it can perform more than one task at a
time.
1. single threaded process
2. mulithreaded process
web browser,video gaming app

Operating System Concepts – 9th Edition 4.3 Silberschatz, Galvin and Gagne ©2013
 Single and Multithreaded Processes

Operating System Concepts – 9th Edition 4.4 Silberschatz, Galvin and Gagne ©2013
 Benefits

● benifits of multithreaded programming can be broken down

into 4 categories.

● Responsiveness – may allow continued execution if part of

process is blocked, especially important for user interfaces
● Resource Sharing – threads share resources of process, easier
than shared memory or message passing
● Economy – cheaper than process creation, thread switching lower
overhead than context switching
● Scalability – process can take advantage of multiprocessor
architectures

Operating System Concepts – 9th Edition 4.5 Silberschatz, Galvin and Gagne ©2013
 Multithreading Models

● Many-to-One

● One-to-One

● Many-to-Many

Operating System Concepts – 9th Edition 4.6 Silberschatz, Galvin and Gagne ©2013
 Many-to-One

● Many user-level threads mapped to single

kernel thread
● One thread blocking causes all to block
● Multiple threads may not run in parallel on
muticore system because only one may
be in kernel at a time
● Few systems currently use this model
● Examples:
● Solaris Green Threads
● GNU Portable Threads

Operating System Concepts – 9th Edition 4.7 Silberschatz, Galvin and Gagne ©2013
 One-to-One
● Each user-level thread maps to kernel thread
● Creating a user-level thread creates a kernel thread
● More concurrency than many-to-one
● Number of threads per process sometimes restricted
due to overhead
● Examples
● Windows
● Linux
● Solaris 9 and later

Operating System Concepts – 9th Edition 4.8 Silberschatz, Galvin and Gagne ©2013
 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 with the ThreadFiber
package

Operating System Concepts – 9th Edition 4.9 Silberschatz, Galvin and Gagne ©2013
 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

Operating System Concepts – 9th Edition 4.10 Silberschatz, Galvin and Gagne ©2013
 Threading Issues
● Semantics of fork() and exec() system calls
● Signal handling
● Synchronous and asynchronous
● Thread cancellation of target thread
● Asynchronous or deferred
● Thread-local storage
● Scheduler Activations

Operating System Concepts – 9th Edition 4.11 Silberschatz, Galvin and Gagne ©2013
 Semantics of fork() and exec()

● Does fork()duplicate only the calling thread or all threads?

● Some UNIXes have two versions of fork
● Which one to use depends on the application.
● if exec() is called immediately after fork(), then duplicating
all threads is unnecessary as program specified inside
exec() as parameter will be replaced by the process.
● exec() usually works as normal – replace the running
process including all threads

Operating System Concepts – 9th Edition 4.12 Silberschatz, Galvin and Gagne ©2013
 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,all signals follows
same pattern:
1. Signal is generated by particular event
2. Signal is delivered to a process
3. Signal is handled by one of two signal handlers:
1. default
2. user-defined
● Every signal has default handler that kernel runs when
handling signal
● User-defined signal handler can override default

Operating System Concepts – 9th Edition 4.13 Silberschatz, Galvin and Gagne ©2013
 Synchronous & asynchronous signal
A signal may be received synchronously or asynchronously.
Ex; synchronous signal include illegal memory access , dividing by zero
synchronous signals are delivered to the same process that performed the
operation that caused the signal.

Asynchronous: ex: terminating a process with specific key strokes, having a

timer expire.
When a signal is generated by the event external to a running process , that
process receives the signal asynchronously.An asynchronous signal is sent to
another process.
Synchronous signal delivered to the thread causing the signal & not to other
threads in a process.
But in Asynchronous signal should be sent to all the threads (control-C)

Operating System Concepts – 9th Edition 4.14 Silberschatz, Galvin and Gagne ©2013
 Signal Handling (Cont.)

● For single-threaded, signal delivered to process

● Where should a signal be delivered for multi-threaded?
● 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
The standard UNIX function for delivering a signal is:
kill(pid_t pid, int signal )

Operating System Concepts – 9th Edition 4.15 Silberschatz, Galvin and Gagne ©2013
 Thread Cancellation
● Terminating a thread before it has finished
● ex: user presses a button on web browser to stop and all the threads
loading the image should be cancelled.
● Thread to be canceled is target thread
● Two general approaches:
● Asynchronous cancellation terminates the target thread
immediately
● Deferred cancellation allows the target thread to periodically
check if it should be cancelled
asynchronous cancellation becomes troublesome, in situations where
resources have been allocated to the cancelled threads or in the middle
of updating data which is shared by other threads.
This could be overcomed by deferred thread cancellation approach
where cancellation occurs only when the flag s checked to
determined whether or not it should be cancelled.

Operating System Concepts – 9th Edition 4.16 Silberschatz, Galvin and Gagne ©2013
 Thread Cancellation (Cont.)
● Invoking thread cancellation requests cancellation, but actual
cancellation depends on thread state

● If thread has cancellation disabled, cancellation remains pending

until thread enables it
● Default type is deferred
● Cancellation only occurs when thread reaches cancellation
point
4 one technique to establish a cancellation point is to invoke
pthread_testcancel()
4 if cancellation request is found to be pending, Then
cleanup handler is invoked.
4 This function allows any resources a thread may have
acquired to be released before thread is terminated.
Operating System Concepts – 9th Edition 4.17 Silberschatz, Galvin and Gagne ©2013
 Thread-Local Storage

● Thread-local storage (TLS) allows each thread to have its own

copy of data
● ex: transaction processing system
● Useful when you do not have control over the thread creation
process (i.e., when using a thread pool)
● Different from local variables
● Local variables visible only during single function invocation
● TLS visible across function invocations
● TLS is unique to each thread

Operating System Concepts – 9th Edition 4.18 Silberschatz, Galvin and Gagne ©2013
 Scheduler Activations
● Both M:M and Two-level models require
communication to maintain the appropriate
number of kernel threads allocated to the
application
● Typically these models use an intermediate data
structure between user and kernel threads –
lightweight process (LWP)
● Appears to be a virtual processor on which
process can schedule user thread to run
● Each LWP attached to kernel thread
● How many LWPs to create?
one scheme for communication b/w user thread
library and kernel is known as scheduler activation

Operating System Concepts – 9th Edition 4.19 Silberschatz, Galvin and Gagne ©2013
 scheduler activations

● it works as follows: kernel [provides application with a set of LWP &

application can schedule user threads onto an LWP.
● kernel must inform an application about certain events.
● This procedure is known as upcalls.
● Scheduler activations provide upcalls - a communication mechanism from
the kernel to the upcall handler in the thread library
● This communication allows an application to maintain the correct number
kernel threads

Operating System Concepts – 9th Edition 4.20 Silberschatz, Galvin and Gagne ©2013
 End of Chapter 4

Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013