Chapter 3 Threads

ICT Academy of Tamil Nadu
An Initiative of Government of India,

Government of Tamil Nadu and CII
Define a thread with its advantages

Understand the models for multithreading
Study the critical section problem
Illustrate semaphores with its types
Understand various synchronization mechanisms
Classify four classical problems of synchronization

Understand a deadlock situation and describe how it can be
prevented, avoided, detected and recovered



A thread is a program execution that uses the resources of a
process.
Since threads have some of the properties of a process, it is
sometimes called as lightweight process
Thread comprises:
Thread ID
A program counter
A register set
A Stack

Process
Thread 2
Time
Thread 1

Preemptive multithreading
Allows the operating system to determine time for context switching.
Disadvantage Context switching happens in an inappropriate time
and may leaf to negative effects. This may be avoided by cooperative
multithreading.
Cooperative multithreading
Depends on the threads themselves to release control once they are at
a stopping point.
Disadvantage Problems may be created if any thread waits for a
resource availability

Heavyweight process
Information global to
all threads in a
process
Information local to
each thread
Address space
Other global process data
.
.
.
Registers
Registers
Registers
Stack
Stack
Stack
Mask
Mask
Mask
TSD
TSD
TSD
Threads

Data
Code
Open Files
Registers
Signal
Stack
Thread
Data
Code
Open Files
Signal
Registers
Registers
Registers
Stack
Stack
Stack
Thread
Thread
Thread

A process with multiple threads can be viewed as a large

server. E.g: Print Server
As threads share common data, inter process communication
is not needed
Threads use very little resources and they do not need new
address space, global data, program code or operating system

resources
Context switching is faster when working with threads.

Threads share CPU and only one active thread at a time

Threads within a process execute sequentially
Thread can create children
If one thread is blocked another thread can run

10
Threads are not dependent on one another

All threads can access every address in the task
Threads assist one another

11
User
Level
Threads
Kernel
Level
Threads

12
User level threads do not require the operating system to

support threads
User level threads are more portable as they do not rely on a
particular operating systems thread

Program counter, registers, stack and small control block are
represented in a simple way
Without kernel intervention, threads are created, switched and
synchronized.
Threading library controls the scheduling.

13
User level threads are also

called as many-to-one
thread mapping.
Threads
Process Scheduling
Thread Scheduling
CPU

14
Improved performance by which the kernel can dispatch

processs threads to several processors at one time.
Kernel manages each thread individually by which each
processs ready thread is dispatched even if the thread is
blocked.

15
Kernel Level
Threads
Kernel level threads are

also called as one-to-one
thread mapping.
Threads
Process Scheduling
Thread Scheduling
CPU

16
User level threads
Kernel level threads
User level threads are faster to create and Kernel level threads are slower to create and
manage.
manage.
Implemented by a thread library at the user Operating system support directly to Kernel
level.
threads.
User level thread can run on any operating Kernel level threads are specific to the operating
system.
system.
Support provided at the user level called user Support may be provided by Kernel is called
level thread.
Kernel level threads.
Multithread
application
cannot
advantage of multiprocessing.
take Kernel
routines
multithreaded.
themselves
can

be
17
Software Design
Performance
Cooperation

18
Whenever a thread is created, it is put into the ready state.

When the task is completed or terminated, a thread in the
running state enters the dead state
It enters blocked state when it must wait for the completion
of any I/O request
If a thread is waiting for any event, it enters the waiting state.
A thread can enter the sleeping state for a period of time

19
Create
Exit
Suspend
Resume
Sleep
Wake

20
Cancel
Join

21

22
One-to-One
Model
Many-toOne Model
Many-toMany
Model

23
User Thread
Kernel Thread

24
User Thread
Kernel Thread

25
User Thread
The Critical Section Problem
Kernel Thread

26

27
When one process is using shared changeable data in its

critical section, no other process is permitted to execute in its
critical section.
No two processes are executing in their critical sections at the
same time.

28
do
{
entry section
critical section
exit section
remainder section
} while(1);

29
Wait
Enter
Critical Section
Exit
Signal

30
Two or more processes are varying with each other; in order

to reach completion
The process moves ahead of the other process.
When multiple processes access the same data, the execution
takes place depending on the order of the access.

31
Three goals for solving the critical section problem:

Mutual exclusion
Progress
Bounded waiting
Two general approaches to handle critical section:

Preemptive kernels
Non-preemptive kernels

32
For any two process, the data variables that are shared are:
int a;
boolean flag [2];
Three algorithms are used to solve the problem

33
All processes share the common integer variable a that has

been initialized to 0 0r 1
do
{
while (a!=i);
//critical section
a=j;
//remainder section
} while(1);

34
The variable a is replaced with the array as Boolean a[2]

do
{
a[i]=true;
while(a[j])
//critical section
a[i]=false;
//remainder Section
} while(1);

35
Each process shares two variables as:

Boolean a[2]
int b
do
{
a[i]=true;
b=j;
while(a[j]&&b==j)
//critical Section
a[i]=false
//remainder Section
} while(1)

36

37
Any solution to the critical-section problem requires a simple

tool called lock to protect the critical region
Modern computer system either test or modify the content or
swap the contents automatically like one uninterruptible unit
The TestAndSet() instruction is defined as below:
boolean TestAndSet (boolean *b)
{
boolean a=*b;
*b=true;
return a;
}
38
Structure of process Pi is shown below:

do
{
while (TestAndSet(&lock));
//critical section
lock=false;
//remainder section
} while (1);

39
Swap() instruction is defined as below:
void Swap(boolean *x, boolean *y)

{
boolean z = *x;
*x = *y;
*y = z;
}

40
Mutual exclusion implementation with the Swap() instruction

is given below:
do
{
key = TRUE;
while (key == TRUE)
Swap (&lock, &key);
//critical section
lock = FALSE;
//remainder section
}while (1);

41

42
A semaphore is essentially an integer protected variable S

which is treated in a special way
The following are the two calls associated with a semaphore,
Lock
Unlock
A semaphore S is an integer variable that is accessed only

through two standard atomic operations: wait() and signal()

43
Definition of wait() is given below:

wait(S)
{
while S <= 0
S=S-1;
}
Definition of signal() is given below:

signal(S)
{
S=S+1;
}

44
All the system resources are used by the operating systems.

Semaphore is used to assign a particular resource to a
program.
Once the resources is used or no longer needed by the
program, the semaphore is returned back to the operating
system so that it can be allocated to another program

45
They are machine independent.

They are simple to implement.
They can be easily debugged.
There
are
different
critical
sections
with
different
semaphores.
They acquire many resources simultaneously.

46
Binary
semaphores
Counting
semaphores

47
An integer value that can range only between 0 and 1

It can be used with multiple processes that solve the critical
section problems

48
The implementation mechanism of the binary semaphores is

very simple.

49
When a process that is executing in its critical section exists,

the waiting processes decrements to 0 and enter its critical
section.
Process that waits to enter its critical section will perform
busy waiting thus wasting CPU cycles.

50
A non-binary semaphore that can take any non-negative

integer value

51
All the waiting processes enter their critical section in FCFS

order. Thus bounded waiting is fully met.
A process that waits does not perform busy waiting thus
saving some CPU cycles.

52
The implementation mechanism of the counting semaphores

is more complex as it involves FCFS queue.
The context switches will involve certain overheads.

53
Full
Used when the counter for number of slots indicates full.
Empty
Used when the counter doe number of slots indicates empty.
Mutex
Producer and consumer will not access modifiable shared
section of the buffer.

54

55
A solution to a synchronization problem can be reached by

inter process communication using semaphores
It must also hold three important properties:
Correctness
Maximum concurrency
No busy waits

56
Consider a pool that consists of 11 buffers, each capable of

holding one item
Semaphore empty is initialized to value n and semaphore
full is initialized to value 0

57
do
{
.
.
//produces an item
.
.
wait (empty);
wait (mutex);
.
.
//Add an item
.
.
signal (mutex);
signal (full);
}while(1);

58
do
{
wait (full);
wait (mutex);
.
.
//Remove an item
.
.
signal (mutex);
signal (empty);
.
.
//consume the item
.
.
}while(1);

59
Consider a data area that is shared among a number of

processes
Number of readers can read from the data area but only one
writer can write data into the data area
If a writer is writing to the data area, then no reader is
allowed to read it
Also if a reader is reading from the data area, no other reader
reads the data from the data area


60
An object is shared among many threads, each belonging to

one of the following two classes:
Readers: read data, never modify it
Writers: read data and modify it

61
The reader process shares the following declaration:

semaphore mutex, w;
int i;
Structure of the writer process:
do
{
wait (w);
.
.
// writing is performed
.
.
signal (w) ;
}while(1);
62
Structure of the reader process:

mutex and w are initalized to 1
i is initlaized to 0
w is common to both reader and

writer
mutex ensure mutual exclusion
when i is modified
i is the count variable used to keep
track of the number of processes
currently reading the object
do
{
wait (mutex);
i++;
if (i==1)
wait (w);
signal (mutex);
.
.
//reading is performed
.
.
wait (mutex);
i--;
if (i==0)
signal (w);
signal (mutex);
}while(1);
63
There are five philosophers seated around a circular table

with a plate and two forks
The philosophers share a circular table bounded by five
chairs, each belonging to one philosopher
In the center of the table is a bowl of rice, and the table is
placed with five single chopsticks

64

65
There are at most four philosophers who will be sitting

simultaneously at the circular table.
The philosopher is allowed to pick up the chopsticks only if
both chopsticks are available (normally it is picked up in a
critical section)
Odd philosopher picks up left chopstick first and then the

right chopstick,
Even philosopher picks up the right chopstick first and then
her left chopstick.

66

67
Deadlock is a situation in which two process namely Process

A and Process B shares the resources specifically Resource A
and Resource B which prevents each other from accessing the
resource, resulting in both programs terminating the function.
A deadlock is a situation in which some processes wait for
each others actions indefinitely.

68
Process
A
Process
B
Resource A
Resource B

69
Mutual exclusion
Only one process accessing one resource.
Resource holding
One process holding one resource which do not release that process and
waits for other process for accessing purpose.
No preemption
A resource that cannot be released from the process
Circular wait
All processes holds one or more resources that demands the next process in
the chain

70

71
1. Deadlocks on file requests

2. Deadlocks in databases
3. Deadlocks in dedicated device allocation
4. Deadlocks in multiple device allocation
5. Deadlocks in spooling
6. Deadlocks in disk sharing
7. Deadlocks in a network

72
Deadlock happens when a process holds files for complete

duration of the execution
Once this completes, the process can release the files F1 and
F2
A process is withdrawn or removed from the resource and
this makes the deadlock to wait for a longer time

73

74
Two processes can access the resource and the records in the
database is locked
3 different levels of locking :
Entire database is locked
A subsection of the database is locked
Individual record is locked

75
If the records are not locked then races condition takes place
P1 access R1 and locks it.
P2 access R2 and locks it.
P1 request R2 but R2 is locked by P2.
P2 request R1 but R1 is locked by P1.

76
If the devices available are less in number, then deadlock

occurs.
E.g., printers, plotters or CD drives.
P1 requests printer 1 and gets it.
P2 requests printer 2 and gets it.
P1 requests printer 2 but printer 2 is blocked by P2.

P2 requests printer 1 but printer 1 is blocked by P1.

77
When many processes request for a resource it hold on to the

dedicated devices while other processes also proceeds in a
same manner.

78
Many systems have distorted devices such as a printer, plotter

into a device that can be shared by high-speed device, a disk
and the CPU.
Disk acts as a temporary storage area to accept output from

users for all output till printer is prepared to accept it
(spooling).
If a printer requires process result before it will starts printing,
but spooling system fills available disk space with only
partially completed output.

79
Disks are designed so that it is common for 2 processes to

share different regions of same disk.
All processes that share the data send different commands for
using the resource.

80

81
A network if it is in traffic does not have protocols through

which the flow of messages can be controlled

82
Deadlock
Prevention
Prevent one of the

four conditions
from occurring.
Deadlock
Avoidance
Avoid the deadlock

if it becomes
probable.
Deadlock
detection
Detect the
deadlock when it
occurs and recover
from it gracefully.

83
Mutual
Exclusion
Resource
Holding
No
Preemption
Circular
Wait

84
Here some resources namely Memory unit, CPU and other

devices may be allocated to only one user at a time.
Spooling can be used for some resources
It holds for resources that cannot be shared

Example: Printer cannot be shared
Resources that can be shared do not lead to deadlock

Example: Read-only file

85
Every process request all resources so that the resources are

forced to run to completion
The degree of multiprogramming is decreased
Some devices can be inactive as the job allocated would be used all the
time

86
The resources are deallocated from the process

Good if process state is easily saved and restored.
Bad for I/O devices and also if the files are modified

87
Can be prevented if the circle is not formed.

Havenders solution by putting numbers for the resources
Each process requests resources in ascending order
Process requesting number one is allocated first

88
Safe State
All process gets all resources requested by them.
Process may be allocated in the following order
P1, P2, P3,,Pn
For a system in safe state, there is no deadlock
Unsafe State
When Pi enters to terminate state, then the next process namely Pi+1, in
its order, receives that resource

89
deadlock
unsafe
state
safe
state

90
It handles only one instance for resource types
Each process with a directed edge of graph is allocated to each

resource
Claim edge: Dashed line by which a process is allocated to a resource
Assignment edge: Directed line by which a resource is released by a
process
The resources that is allocated will reverse the edge of the direction
The resources that is released by the process is returned to the edge
of the direction
No cycle of graph is created

91

92

93
It handles multiple instances for resource types

All process must be used at a maximum rate
A process requesting a resource needs to wait
When it gets the resource, it must place them in a finite
amount of time

94
Let n be the number of process and m be the number of

resources
Available : vector [1..m]
Max: matrix [1..n, 1..m]
Allocation: matrix [1..n, 1..m]
Need: matrix [1..n, 1..m]

Need[i,j] = Max[i,j] Allocation [i,j]

95
Work and Finish are two vector with length m and n namely
Work=vector[1..m] and Finish=vector[1..n]
Work = Available
Finish [i] = False where i= 0, 1,,n-1
Find i where,
Finish[i]=False
Need[i]<=Work
Work = Work+Allocation
Finish[i]=True, then go to Step 1
If Finish[i]=True, then the system is in safe state


96
If Request[i]<=Need[i], go to step 2
If Request[i]<=Available, go to step 3
Available= Available- Request[i]
Allocation[i]=Allocation[i]+Request[i]
Need[i]=Need[i]- Request[i]

97
An algorithm that periodically defines the state of the system

to decide whether a deadlock has occurred in the system or
not
An algorithm to recover from the deadlock

98
One instance for one resource

A resource which has only one instance makes use of variant of the
resource allocation graph. This is called wait-for graph
Pi waits for Pj to release the resource that Pi requires.

An algorithm is used to identify the cycle in the graph which needs an
order of n2 operations. Here n is the number of variants defined in the
graph.

99
Resource Allocation Graph
P5
R1
R3
R4
P1
P2
P3
R2
P4
R5

100
Wait for Graph

P5
P1
P2
P3
P4

101
Multiple instance for one resource

Same as Bankers Algorithm with the following differences
Available : vector [1..m]
Allocation: matrix [1..n, 1..m]

Need: matrix [1..n, 1..m]
Need is replaced by request by which request [i] is the vector of the request
resource i

102
Work and Finish are two vector with length m and n namely
Work=vector[1..m] and Finish=vector[1..n]
Work = Available
If Allocation 0, then Finish[i] = False else Finish[i] = True where i= 0,
1,,n-1
Find i where
Finish[i]=False
Request [i]<=Work

103
Work = Work+Allocation
Finish[i]=True, then go to Step 2
If Finish[i]=False, then the system is said to be deadlocked

state

104
Process
termination
Resource
preemption

105
Order to kill the process can be selected from:

Priority
Computation time
Used resources
Completed resource
No of processes to be terminated
Whether process is interactive or batch

106
Choose the process which is in the deadlock state

Rollback the process
The process is returned to the safe state and the system is restarted
form that safe state
Starvation
The same process can always be selected as the victim by considering
the cost factor

107
A thread is a program execution that uses the resources of a

process and consists of thread ID, a program counter, a
register set, a stack.
The implementation models of thread are user level thread
and kernel level thread.
Threads at the user level are implemented in user-level
libraries rather than using the system calls.

108
Kernel level threads map each thread to its own execution
context.
The thread states are ready, running, blocked, waiting, and
sleeping
The thread operations are create, exit, suspend, resume,
sleep, wake.
Multithreading refers to the ability of an operating system to
support multiple, concurrent paths of execution within a
single process.

109
The three types of multithreading models are many-to-one

model, one-to-one model, many-to-many model.
When one process is using shared changeable data in its
critical section, no other process is permitted to execute in its
critical section.
Race condition is defined by which two or more processes are
varying with each other; in order to reach completion, the
process moves ahead of the other process


110
Mutual exclusion is a situation where one process is executing

in its critical section and no other process is allowed to
execute its critical section.
Simple hardware instructions are used effectively to solve the
critical-section problem. Any solution to the critical-section
problem requires a simple tool called lock to protect the
critical region.

111
Semaphore is a shared integer variable with on-negative

values that can be subjected only to the following operation:
Initialization
The indivisible operations wait and signal
A solution to a synchronization problem can be reached by
inter process communication using semaphores.

112
A deadlock is a situation in which some processes wait for

each others actions indefinitely.
The four conditions of deadlock are mutual exclusion,
resource holding, no preemption, circular wait.
Deadlock may occur on files, databases, device allocation,
spooling ,disk sharing and network.

113
Deadlock can be prevented by one of the four conditions

namely mutual exclusion, resource holding, no preemption,
circular wait.
Deadlock avoidance is the deadlock handling approach by
which the deadlocks are dealt with before they occur.

114
Deadlock can be detected by an algorithm that periodically

defines the state of the system to decide whether a deadlock
has occurred in the system or not.
Deadlock can be recovered by either terminating the process
or preempting the resource.

115

Chapter 3 Threads

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Chapter 3 Threads

Încărcat de

Drepturi de autor:

Formate disponibile

ICT Academy of Tamil Nadu

An Initiative of Government of India,

Define a thread with its advantages

Classify four classical problems of synchronization

prevented, avoided, detected and recovered

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

A thread is a program execution that uses the resources of a

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

A process with multiple threads can be viewed as a large

address space, global data, program code or operating system

An Initiative of Government of India,

Threads share CPU and only one active thread at a time

ICT Academy of Tamil Nadu

An Initiative of Government of India,

Threads are not dependent on one another

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

User level threads do not require the operating system to

particular operating systems thread

An Initiative of Government of India,

User level threads are also

ICT Academy of Tamil Nadu

An Initiative of Government of India,

Improved performance by which the kernel can dispatch

ICT Academy of Tamil Nadu

An Initiative of Government of India,

Kernel level threads are

ICT Academy of Tamil Nadu

An Initiative of Government of India,

User level threads

Kernel level threads

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

Whenever a thread is created, it is put into the ready state.

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

ICT Academy of Tamil Nadu

An Initiative of Government of India,

The Critical Section Problem

ICT Academy of Tamil Nadu

void Swap(boolean x, boolean y)