Topic 4: Threads

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