1 Program5 Due Friday, March 27. 2 Prog4 user_thread... amount = … invoke delegate transact...

transcript

Program5

Due Friday, March 27

user_thread

. . .amount = …

invoke delegate transact (amount). . .

mainThread

. . .Total + = amount …

user_thread

. . .amount = …

user_thread

. . .amount = …

Data Shared by Multiple Threads

user_thread

. . .amount = …

Total += amount. . .

user_thread

. . .amount = …

user_thread

. . .amount = …

Time Sharing

threadOne

threadTwo

Time line

The threads don’t know when the time out will occur.

Data Shared by Multiple Threads

user_thread

. . .amount = …

Total += amount// In assembly// Load Total// Add amount// Save Total

user_thread

. . .amount = …

Total += amount// In assembly// Load Total// Add amount// Save Total

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

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.

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.

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

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.

Monitor Methods

• Enter • Exit

• TryEnter • Wait • Pulse • PulseAll• . . .

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). . .

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

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.

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

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)

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

Monitor.Exit(myQueue)21

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.

ReaderWriterLock

• Starvation

• Not a FIFO solution

• We don’t use the lock!

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!

FIFO Solution• ReaderWriter Class

– FIFO Queue

– ReaderWriterEvent: AutoResetEvent

• To wait in the FIFO queue

– EndProgram: AutoResetEvent

• To terminate the program

– ID– Type– Sub Run

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

(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

(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

1 Program5 Due Friday, March 27. 2 Prog4 user_thread... amount = … invoke delegate transact...

Documents