Topic 4: Threads

cavalcadejewelSoftware and s/w Development

Nov 18, 2013 (3 years and 8 months ago)

95 views

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