1 program5 due friday, march 27. 2 prog4 user_thread... amount = … invoke delegate transact...
TRANSCRIPT
1
Program5
Due Friday, March 27
2
Prog4
user_thread
. . .amount = …
invoke delegate transact (amount). . .
mainThread
. . .Total + = amount …
user_thread
. . .amount = …
invoke delegate transact (amount). . .
user_thread
. . .amount = …
invoke delegate transact (amount). . .
Total
3
Data Shared by Multiple Threads
user_thread
. . .amount = …
Total += amount. . .
user_thread
. . .amount = …
Total += amount. . .
user_thread
. . .amount = …
Total += amount. . .
Total
4
Time Sharing
threadOne
threadTwo
Time line
The threads don’t know when the time out will occur.
5
Data Shared by Multiple Threads
user_thread
. . .amount = …
Total += amount// In assembly// Load Total// Add amount// Save Total
. . .
Total
user_thread
. . .amount = …
Total += amount// In assembly// Load Total// Add amount// Save Total
. . .
6
Mutual Exclusion
user_thread
Start runningamount = 50
Total += 50// In assembly// Load TotalTotal: 1000Time Out
Continue runningTotal: 1000// Add amount// Save TotalTotal: 1050
. . .
Total: 1000 900 1050
user_thread
Start runningamount = -100
Total += -100// In assembly// Load TotalTotal: 1000// Add amount// Save TotalTotal: 900
. . .
Critical Section
When accessing shared data.
Should be executed as a single statement.
Total += amount
// Load Total
// Add amount
// Save Total7
Two Classes for Mutual Exclusion
• MutEx
• Monitor
8
9
Class MutEx (Semaphore)
A synchronization primitive that can also be used for inter-process synchronization.
When two or more threads need to access a shared resource at the same time, the system needs a synchronization mechanism to ensure that only one thread at a time uses the resource.
MutEx is a synchronization primitive that grants exclusive access to the shared resource to only one thread.
If a thread acquires a MutEx, the second thread that wants to acquire that MutEx is suspended until the first thread releases the MutEx.
10
Class Monitor
Provides a mechanism that synchronizes access to objects.
The Monitor class controls access to objects by granting a lock for an object to a single thread.
Object locks provide the ability to restrict access to a block of code, commonly called a critical section.
While a thread owns the lock for an object, no other thread can acquire that lock.
11
Class Monitor Features
• It is associated with an object on demand.
• It is unbound, which means it can be accessed directly from any context.
• An instance of the Monitor class cannot be created.
• Not inheritable
Public NotInheritable Class Monitor
• Shared methods
12
Class Monitor
The following information is maintained for each synchronized object:
• A reference to the thread that currently holds the lock.
• A reference to a ready queue, which contains the threads that are ready to obtain the lock.
• A reference to a waiting queue, which contains the threads that are waiting for notification of a change in the state of the locked object.
13
Monitor Methods
• Enter • Exit
• TryEnter • Wait • Pulse • PulseAll• . . .
14
Using Class Monitor
Private Total As Integer‘ Cannot use Monitor on integersPrivate TotalObj As New Object
user_thread
. . .amount = 50
Monitor.Enter(TotalObj)(CriticalSection)Total += 50// In assembly// Load Total// Add amount// Save TotalMonitor.Exit(TotalObj). . .
15
Using Class Monitor
user_thread
Start runningamount = 50
Monitor.Enter(TotalObj)(CriticalSection)Total += 50// In assembly// Load TotalTotal: 1000Time Out
Continue runningTotal: 1000// Add amount// Save TotalTotal: 1050Monitor.Exit(TotalObj)
. . .
TotalObj
Total: 1000 1050 950
user_thread
Start runningamount = -100
Monitor.Enter(TotalObj)(wait here)(continue)(CriticalSection)Total += -100// In assembly// Load TotalTotal: 1050// Add amount// Save TotalTotal: 950Monitor.Exit(TotalObj)
. . .
ManualResetEvent &AutoResetEvent
• Class ManualResetEvent
– Set: change the state to signaled (Green light)
– WaitOne: wait for signal
– Reset: change the state to non-signaled (Red Light)
– Like a traffic light
• Class AutoResetEvent
– Set: change the state to signaled (Green light)
– WaitOne: wait for signal
– State becomes non-signaled after a waiting thread released
– Like a Stop sign (combined with traffic light): one at a time
– (Reset): change the state to non-signaled (Red Light)16
17
Queue Class
• Represents a first-in, first-out collection of objects.
• This class implements a queue as a circular array.
• Public static (Shared in Visual Basic) members of this type are thread safe.
• Any instance members are not guaranteed to be thread safe.
18
Queue Constructor
Queue:
Initializes a new instance of the Queue class that is empty, has the default initial capacity, and uses the default growth factor.
Queue(Int32, Single):
Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the specified growth factor.
. . .
Queue MethodsPrivate myQueue As Queue = New Queue
' Puts obj at the end of the queue
' Any obj, could be a thread object
myQueue.Enqueue(obj)
' Takes the first obj from the queue
obj = myQueue.Dequeue
' Checks if the queue is empty
If myQueue.Count > 0 Then
' Points to the first obj of the queue
obj = myQueue.Peek
19
Multiple Threads Accessing One Same Queue
Any instance members are not guaranteed to be thread safe.
Private myQueue As Queue = New Queue
‘ To guarantee at most one thread accessing the queue Monitor.Enter(myQueue)
myQueue.Enqueue(obj)
' Could do other things
' Exits the queue waking up next waiting thread if any
Monitor.Exit(myQueue)
20
Multiple Threads Accessing One Same Queue
Monitor.Enter(myQueue)
' Checks if the queue is empty
If myQueue.Count > 0 Then
' Points to the first obj of the queue
obj = myQueue.Peek
If ... Then
obj = myQueue.Dequeue
. . .
End If
End If
Monitor.Exit(myQueue)21
22
Prog5: Readers and Writers
There is a data area shared among a number of threads
File, Memory, Registers, ...
Variable Total of Integer
Readers: Read data only
Writers: Modify data
Requirements:
Any number of Readers may simultaneously read the data.
A Writer requires exclusive access to the data.
First In First Out (FIFO) rule.
23
ReaderWriterLock
• Starvation
• Not a FIFO solution
• We don’t use the lock!
24
FIFO Solution• DatabaseClass
– Total
– ReaderCount (RC)
• Number of readers reading the data
– WriterCount (WC)
• Number of writers writing the data
• Could be a Boolean
– DataObj• To use Monitor on RC and/or WC
• Not thread Safe!
25
FIFO Solution• ReaderWriter Class
– FIFO Queue
– ReaderWriterEvent: AutoResetEvent
• To wait in the FIFO queue
– EndProgram: AutoResetEvent
• To terminate the program
– ID– Type– Sub Run
26
FIFO Solution
• Reader class and Writer Class– Sub-class of ReaderWriter
– Overrides ID– Overrides Type– Overrides Run
• Mutual exclusion!• FIFO!• No Deadlock!
Pseudo code for the Run method of Reader
27
(For one reader and no loop inside: no spindown)
If the queue is not empty or the database status is writing Add itself to the queue Wait for _ReaderWriterEvent Wakeup next reader before accessing the database
Increase reader count by oneReading the value
Decrease reader count by oneIf the database status is empty Wakeup next one in the queue
Pseudo code for the Run method of Writer
28
(For one writer and no loop inside: no spindown)
If the queue is not empty or the database status is not empty Add itself to the queue Wait for _ReaderWriterEvent (Wakeup next reader before accessing the database)
Increase writer count by oneUpdate the value
Decrease writer count by one(If the database status is empty)Wakeup next one in the queue