Software development is a team effort. Unless team members cooperate with one another, synchronize their work with the rest of the team, the team can’t go far. Similarly if in a program there are several threads running, unless their activities are synchronized with one another the disaster is not far away. Windows supports four types of objects—Critical sections, Mutexes, Events and Semaphores—that can help us to coordinate the activities of concurrently running threads in an application. Of these Critical section is the simplest to use. If the resources like variables, structures, linked lists, etc. are shared by two or more threads, critical section can serialize the accesses to these resources. However, the resources must belong to the same process as critical section does not work across the processes.

If a thread needs exclusive access to a resource then it can lock and unlock the same. The resource in such a case is referred to as a ‘critical section’. If thread B tries to lock a critical section that is locked by thread A, then thread B is denied an access to the critical section until thread A unlocks it.

Let us now see an example of critical section where names of students are stored in a CStringList object. A thread sortthread sorts the names while another thread addthread adds a new name to the list. We have blocked the thread that adds the name to the list if the sorting thread is in progress. Also, we have blocked the thread that sorts the names if addition of names is in progress.

Create a dialog based application called ‘critical’. Add two buttons, an edit box and a list box to the dialog. The controls, their IDs and variables associated with them are given below:

The dialog template after adding the controls would appear as shown below.

The name entered by the user in the edit box will get added to the string list if ‘Add’ button is clicked. The list box will show the sorted records if ‘Sort’ button is clicked.

Declare a global structure in ‘criticalDlg.h’ file as given below:

struct THREADPARAMS

{

CString itemstr ;

CListBox *list ;

CCriticalSection *cr ;

} ;

#include ‘afxmt.h’ file in ‘criticalDlg.h’ file. This makes the CCriticalSection class available to our application. Add a private variable m_c of type CCriticalSection in CCriticalDlg class. Also add a static variable m_strlist of type CStringList to the CCriticalDlg class. Add the following statement in ‘criticalDlg.cpp’.

CListBox CCriticalDlg::m_sortlist ;

Add the following code in OnInitDialog( ) function.

BOOL CCriticalDlg::OnInitDialog( )

{

// Code added by AppWizard

CStdioFile f ;

CString str ;

if ( f.Open ( “data.txt”, CFile::modeReadWrite ) != 0 )

{

while ( f.ReadString ( str ) != NULL )

m_strlist.AddTail ( str ) ;

}

f.Close( ) ;

return TRUE ;

}

The ‘data.txt’ file contains the names of students. Here, we have read the records from the file using CStdioFile::ReadString( ) function and added them to the string list using CStringList::AddTail( ) function.

Add OnSort( ) handler for the ‘Sort’ button. The code of OnSort( ) function is given below:

void CCriticalDlg::OnSort( )

{

THREADPARAMS *th = new THREADPARAMS ;

th -> itemstr = “” ;

th -> list = &m_sortlist ;

th -> cr = &m_c ;

AfxBeginThread ( sortthread, ( LPVOID ) th ) ;

}

Here we have initialised the elements of THREADPARAMS structure that we are passing to the sortthread( ) function. We have started the thread by calling AfxBeginThread( ) function. The code of the sortthread( ) function is given below:

UINT sortthread ( LPVOID param )

{

THREADPARAMS *th = ( THREADPARAMS* ) param ;

int i, j ;

CString l1, l2 ;

POSITION p1, p2 ;

th -> cr -> Lock( ) ;

int count = CCriticalDlg::m_strlist.GetCount( ) ;

for ( j = 0 ; j < count ; j++ )

{

p1 = CCriticalDlg::m_strlist.GetHeadPosition( ) ;

for ( i = 0 ; i < count – 1 ; i++ )

{

p2 = p1 ;

l1 = CCriticalDlg::m_strlist.GetNext ( p1 ) ;

l2 = CCriticalDlg::m_strlist.GetAt ( p1 ) ;

if ( l1 > l2 )

{

CCriticalDlg::m_strlist.SetAt ( p2, l2 ) ;

CCriticalDlg::m_strlist.SetAt ( p1, l1 ) ;

}

}

}

th -> list -> ResetContent( ) ;

POSITION pos = CCriticalDlg::m_strlist.GetHeadPosition( ) ;

for ( i = 0 ; i < count ; i++ )

th -> list -> AddString ( CCriticalDlg::m_strlist.GetNext ( pos ) ) ;

th -> cr -> Unlock( ) ;

return 0 ;

}

Here, we have first locked the object of CStringList class using CCriticalSection::Lock( ) function. Next we have sorted the list using the usual ‘bubble sort’ sorting logic. CStringList::GetNext( ) function gives the string at the specified position and sets the POSITION variable to point to the next entry. CStringList::GetNext( ) function gets the string at the given position. The sorted list is then displayed in the list box. After the thread is through with its job the object is unlocked using CCriticalSection::Unlock( ) function.

Add OnAdd( ) handler for the Add button and write the following code in it.

void CCriticalDlg::OnAdd( )

{

UpdateData ( TRUE ) ;

THREADPARAMS *th = new THREADPARAMS ;

th -> itemstr = m_addstr ;

th -> cr = &m_c ;

AfxBeginThread ( addthread, ( LPVOID ) th ) ;

}

UpdateData( TRUE ) transfers the name from edit box to m_addstr variable. We have initialised the THREADPARAMS structure with values that we intend to pass to the addthread( ) function. Next, we have started the thread by calling AfxBeginThread( ) function.

The code of the addthread( ) function is given below:

UINT addthread ( LPVOID param )

{

THREADPARAMS *th = ( THREADPARAMS* ) param ;

th -> cr -> Lock( ) ;

if ( !th -> itemstr.IsEmpty( ) )

CCriticalDlg::m_strlist.AddTail ( th -> itemstr ) ;

th -> cr -> Unlock( ) ;

return 0;

}

In this function, the critical section, i.e., m_strlist is locked using CCriticalSection::Lock( ). Now no other thread can use this object unless this thread unlocks it by calling CCriticalSection::UnLock( ) function.

Don’t forget to declare the thread functions in ‘criticalDlg.cpp’ as given below:

UINT addthread ( LPVOID param ) ;

UINT sortthread ( LPVOID param ) ;

Finally, add the OnOK( ) handler to write back the updated string list to the file. Its code is given below:

void CCriticalDlg::OnOK( )

{

CFile::Remove ( “data.txt” ) ;

CStdioFile f ;

if ( f.Open ( “data.txt”, CFile::modeCreate | CFile::modeReadWrite ) != 0 )

{

POSITION pos = m_strlist.GetHeadPosition( ) ;

CString str ;

for ( int i = 0 ; i < m_strlist.GetCount( ) ; i++ )

{

str = m_strlist.GetNext ( pos ) ;

f.WriteString ( str ) ;

f.WriteString ( “\n” ) ;

}

}

f.Close( ) ;

CDialog::OnOK( ) ;

}

Now run the program. If you click the ‘Sort’ button and immediately follow it by clicking the Add button the add thread would get blocked until the sort thread unlocks the critical section.

Download source code for this project from here Using Critical Section

1. there are two ways to program with multiple threads: use the Microsoft Foundation Class (MFC) library or the C run-time library and the Win32 API.

What is threading ?

A thread is basically a path of execution through a program. It is also the smallest unit of execution. A thread consists of a stack, the state of the CPU registers, and an entry in the execution list of the system scheduler. Each thread can shares all the process’s resources.

A process consists of

1. one or more threads

2. the code,

3. data,

4. other resources of a program in memory.

Ex. open files, semaphores, dynamically allocated memory.

A program executes when the system scheduler gives one of its threads execution control. The scheduler determines which threads should run and when they should run. Threads of lower priority might have to wait while higher priority threads complete their tasks. On multiprocessor machines, the scheduler can move individual threads to different processors to balance the CPU load.

Each thread in a process operates independently. Unless you make them visible to each other, the threads execute individually and are unaware of the other threads in a process. Threads sharing common resources, however, must coordinate their work by using semaphores or another method of inter-process communication.

Library Support – all versions of CRT –c run time libraries supports with the exception of the non-locking versions of some functions

Include Files for Multithreading

Standard include files declare C run-time library functions as they are implemented in the libraries. If you use the Full Optimization (/Ox) or fastcall Calling Convention (/Gr) option, the compiler assumes that all functions should be called using the register calling convention. The run-time library functions were compiled using the C calling convention, and the declarations in the standard include files tell the compiler to generate correct external references to these functions.

C Run-Time Library Functions for Thread Control

All Win32 programs have at least one thread. Any thread can create additional threads. A thread can complete its work quickly and then terminate, or it can stay active for the life of the program.

The LIBCMT and MSVCRT C run-time libraries provide the following functions for thread creation and termination: _beginthread, _beginthreadex and _endthread, _endthreadex.

The _beginthread and _beginthreadex functions create a new thread and return a thread identifier if the operation is successful. The thread terminates automatically if it completes execution, or it can terminate itself with a call to _endthread or _endthreadex.

The _beginthread and _beginthreadex Functions

The _beginthread and _beginthreadex functions create a new thread. A thread shares the code and data segments of a process with other threads in the process but has its own unique register values, stack space, and current instruction address. The system gives CPU time to each thread, so that all threads in a process can execute concurrently.

_beginthread and _beginthreadex are similar to the CreateThread function in the Win32 API but has these differences:

· _beginthread and _beginthreadex let you pass multiple arguments to the thread.

· They initialize certain C run-time library variables. This is important only if you use the C run-time library in your threads.

· CreateThread helps prov
ide control over security attributes. You can use this function to start a thread in a suspended state.

_beginthread and _beginthreadex return a handle to the new thread if successful or an error code if there was an error.

The _endthread and _endthreadex Functions

The _endthread function terminates a thread created by _beginthread (and similarly, _endthreadex terminates a thread created by _beginthreadex). Threads terminate automatically when they finish. _endthread and _endthreadex are useful for conditional termination from within a thread. A thread dedicated to communications processing, for example, can quit if it is unable to get control of the communications port.

VC++ FAQ’s And Interview Questions and Answers

37) What is the difference between process and thread?

Ans: Process is a program in execution whereas thread is a separate path of execution in a program.

38) What is multithreading and what are the methods for inter-thread communication and what is the class in which these methods are defined?

Ans: Multithreading is the mechanism in which more than one thread run independent of each other within the process.

wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class.

wait( ) : When a thread executes a call to wait( ) method, it surrenders the object lock and enters into a waiting state.

notify( ) or notifyAll( ) : To remove a thread from the waiting state, some other thread must make a call to notify( ) or notifyAll( ) method on the same object.

39) What is the class and interface in java to create thread and which is the most advantageous method?

Ans: Thread class and Runnable interface can be used to create threads and using Runnable interface is the most advantageous method to create threads because we need not extend thread class here.

40) What are the states associated in the thread?

Ans: Thread contains ready, running, waiting and dead states.

41) What is synchronization?

Ans: Synchronization is the mechanism that ensures that only one thread is accessed the resources at a time.

42) When you will synchronize a piece of your code?

Ans: When you expect your code will be accessed by different threads and these threads may change a particular data causing data corruption.

43) What is deadlock?

Ans: When two threads are waiting each other and can’t precede the program is said to be deadlock.

44) What
is daemon thread and which method is used to create the daemon thread?

Ans: Daemon thread is a low priority thread which runs intermittently in the back ground doing the garbage collection operation for the java runtime system. setDaemon method is used to create a daemon thread.

40. What is runnable?.

Its an Interface through which Java implements Threads.The class can extend from any class but if it implements Runnable,Threads can be used in that particular application.

41. What is preemptive and Non-preemptive Time Scheduling?.

Preemptive: Running tasks are given small portions of time to execute by using time-slicing.

Non-Preemptive: One task doesn’t give another task a chance to run until its finished or has normally yielded its time.

42. What is synchronization?.

Two or more threads trying to access the same method at the same point of time leads to synchronization.If that particular method is declared as synchronized only one thread can access it at a time. Another thread can access it only if the first thread’s task is complete.

43. What are the various thread priorities?.

(i) Min-Priority-value(1).

(ii) Normal-Priority-value(5).

(iii)Max-Priority-value(10).

44.What is Inter-Thread communication?.

To exchange information between two threads.

48.Throwable class is a sub-class of object and implements Serializable.

83. What is the superclass of exception?. Throwable.

82. What is the return type of interrupt method?. void.

3.Why do threads block on I/O?

Threads block on i/o (that is enters the waiting state) so that other threads

may execute while the i/o

Operation is performed.

5. What is synchronization and why is it important?

With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared object while another thread is in the process of using or updating that object’s value. This often leads to significant errors.

6. Can a lock be acquired on a class?

Yes, a lock can be acquired on a class. This lock is acquired on the class’s Class object.

7. What’s new with the stop(), suspend() and resume() methods in JDK 1.2?

The stop(), suspend() and resume() methods have been deprecated in JDK 1.2.

12. What state does a thread enter when it terminates its processing?

When a thread terminates its processing, it enters the dead state.

23What is the difference between yielding and sleeping?

When a task invokes its yield() method, it returns to the ready state. When a task invokes its sleep() method, it returns to the waiting state.

31. What is the difference between preemptive scheduling and time slicing?

Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence.Under time slicing, a task executes for a predefined slice of time and thenreenters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.

39. When a thread blocks on I/O, what state does it enter?

A thread enters the waiting state when it blocks on I/O.

43. What is a task’s priority and how is it used in scheduling?

A task’s priority is an integer value that identifies the relative order in which it should be executed with respect to other tasks. The scheduler attempts to schedule higher priority tasks before lower priority tasks.

45. When a thread is created and started, what is its initial state?

A thread is in the ready state after it has been created and started.

53. What invokes a thread’s run() method?

After a thread is started, via its start() method or that of the Thread class, the JVM invokes the thread’s run() method when the thread is initially executed.

67. What method is invoked to cause an object to begin executing as a separate thread?

The start() method of the Thread class is invoked to cause an object to begin executing as a separate thread.

72. What is the purpose of the wait(), notify(), and notifyAll() methods?

The wait(),notify(), and notifyAll() methods are used to provide an efficient way for threads to wait for a shared resource. When a thread executes an object’s wait() method, it enters the waiting state. It only enters the ready state after another thread invokes the object’s notify() or notifyAll() methods.

76. What are the high-level thread states?

The high-level thread states are ready, running, waiting, and dead.

82. What is an object’s lock and which object’s have locks?

An object’s lock is a mechanism that is used by multiple threads to obtain synchronized access to the object. A thread may execute a synchronized method of an object only after it has acquired the object’s lock. All objects and classes have locks. A class’s lock is acquired on the class’s Class object.

93. What happens when a thread cannot acquire a lock on an object?

If a thread attempts to execute a synchronized method or synchronized statement and is unable to acquire an object’s lock, it enters the waiting state until the lock becomes available.

134. What happens when you invoke a thread’s interrupt method while it is sleeping or waiting?

When a task’s interrupt() method is executed, the task enters the ready state. The next time the task enters the running state, an InterruptedException is thrown.

149. What state is a thread in when it is executing?

An executing thread is in the running state.

170. How can a dead thread be restarted?

A dead thread cannot be restarted.

174. What are three ways in which a thread can enter the waiting state?

A thread can enter the waiting state by invoking its sleep() method, by blocking on I/O, by unsuccessfully attempting to acquire an object’s lock, or by invoking an object’s wait() method. It can also enter the waiting state by invoking its (deprecated) suspend() method.

191. What method must be implemented by all threads?

All tasks must implement the run() method, whether they are a subclass of Thread or implement the Runnable interface.

194. What are synchronized methods and synchronized statements?

Synchronized methods are methods that are used to control access to an object. A thread only executes a synchronized method after it has acquired the lock for the method’s object or class. Synchronized statements are similar to synchronized methods. A synchronized statement can only be execute
d after a thread has acquired the lock for the object or class referenced in the synchronized statement.

195. What are the two basic ways in which classes that can be run as threads may be defined?

A thread class may be declared as a subclass of Thread, or it may implement the Runnable interface.

VC++ FAQ’s And Interview Questions and Answers

Synchronization – Overview

The concurrent execution of threads and processes in

Win32 is achieved by synchronization mechanisms.

Following methods/objects are used to achieve synchronization

Critical Section

– single process;

– non kernel object

Mutexes

Mutually Exclusive

Critical Section + Multi Processes

Semaphores

Semaphores – keeps trap of resource usage by no of threads

Resource acquired by thread it does Counter ++

Resource released by thread it does Counter–

Event Objects

Signal Set – Reset Events

Auro reset and manual reset

Resource

: memory location, data structure, file…

Buffer

Data

Thread 1:

data

Thread 2:

Critical Sections

• Critical Section

– Portion of a code that accesses a shared resource.

• Critical Section Object

– Provided by Win32 API

– used to enforce mutual exclusion between threads within

a single process.

– Only one Thread at a time is allowed to be “inside” the

critical section.

– Local object

• kernel object

• Define critical section object

– CRITICAL_SECTIONcritical_section;

• Initialized critical section

– VOID InitializeCriticalSection (LPCRITICAL_SECTION

lpCriticalSection);

• Deleting critical section object

– VOID DeleteCriticalSection (LPCRITICAL_SECTION

lpCriticalSection);

2005-10-19 Seong Jong Choi Multithreading_CHAPTER_4-9

• Entering the critical section

– VOID EnterCriticalSection (LPCRITICAL_SECTION

lpCriticalSection);

• Leaving the critical section

– VOID LeaveCriticalSection (LPCRITICAL_SECTION

lpCriticalSection);

• Example : Linked list

typedef struct _Node{

struct _Node *next;

int data;

} Node;

typedef struct _List{

Node *head;

CRITICAL_SECTION Critical_sec;

} List;

List *CreateList(){

List *pList = malloc(sizeof(pList));

pList->head = NULL;

InitializeCriticalSection(&pList->Critical_sec);

return pList;

}

void DeleteList(List *pList)

{

DeleteCriticalSection(&pList->Critical_sec);

free(pList);

}

void AddHead(List *pList, Node *node)

{

EnterCriticalSection(&pList->critical_sec);

node->next = pList->head;

pList->head = node;

LeaveCriticalSection(&pList->Critical_sec);

}

• Example : Linked

AddHead()

Data | head

Data | next

NULL

List

Node

Void Insert(List *pList, Node *afterNode, Node *newnode){

EnterCriticalSection(&pList->critical_sec);

if(afterNode == NULL){

AddHead(pList, newNode);

}

else{

newNode->next = afterNode->next;

afterNode->next = newNode;

}

LeaveCriticalSection(&pList->Critical_sec);

}

Node *next(List *pList, Node *node){

Node* next;

EnterCriticalSection(&pList->Critical_sec);

next = node->next;

LeaveCriticalSection(&pList->Critical_sec);

return next;

}

• Example : Linked list

Insert()

1.

Data | next

Data | next

Data | next

Data | next

Data | next

NULL

AfterNode

newNode

AfterNode

• Example : Linked list

*Next()

Data | next

node

head Data | next Data | next NULL

List node node

Data | next

next

– Critical Section

EnterCriticalSection(pCS)

EnterCriticalSection(pCS)

…

LeaveCriticalSection(pCS)

LeaveCriticalSection(pCS)

2005-10-19 Seong Jong Choi Multithreading_CHAPTER_4-17

• Minimizing Lock Time

– Don’t lock a resource for long time !

– Never call Sleep() or any of the Wait…() APIs inside of a

critical section.

– How often the resource will be used and how quickly a

thread must release the resource.

• Void Dangling Critical Sections

– LeaveCriticalSection()?? thread? ????..?

– Critical section is not kernel object -> there is no way to

tell if the thread currently inside a critical section is

still alive.

Deadlock

Example SwapLists() –p.82

void SwapLists(List *list1, List *list2){

List *tmp_list;

EnterCriticalSection(list1->critical_sec);//context switch

EnterCriticalSection(list2->critical_sec);

tmp_list = list1->head;

list1->head = list2->head;

list2->head = tmp_list;

LeaveCriticalSection(list1->critical_sec);

LeaveCriticalSection(list2->critical_sec);

}

ThreadA SwapLists(home_address_list, work_address_list);

ThreadA SwapLists(work_address_list, home_address_list);

Deadlock

Data | next

Node

head Data | next Data | next NULL

Tmp_list Node Node

Data | next

Node

head Data | next Data | next NULL

List1 Node Node

Data | next

Node

head Data | next Data | next NULL

List2 Node Node

• Deadlock() = “The Deadly Embrace”

• Deadlock will not happen by allocating all the

resources you need as a single operation with

WaitForMultipleObjects(). (later…-> P.91)

• All-or-nothing proposition

The Dining Philosophers

The table set for the dining philosophers

eating

thinking Waiting to eat

Let’s See

the Dining.c

Mutexes

• MUTualExclusion

• Only one thread at a time is allowed to own a mutex, just as

only one thread at a time can enter a critical section.

• A kernel object that will enforce mutual exclusion between

threads even if they are in different processes.

Timeout (see Wait…() func) not

Between Processes Within the same process

Almost 100 times longer

Mutexes Critical section

The comparison of the function

DeleteCriticalSection() CloseHandle()

LeaveCriticalSection() ReleaseMutex()

WaitForSingleObject()

WaitForMultipleObjects()

MsgWaitForMultipleObjects()

EnterCriticalSection()

CreatMutex()

OpenMutex()

InitializeCriticalSection()

CRITICAL_SECTION Mutex Kernel Object

Creating Mutex

HANDLE CreateMutex(

LPSECURITY_ATTRIBUTES lpAttribute,

="MsoNormal" style="color:rgb(51,51,255);font-family:trebuchet ms;">BOOL bInitialOwner,

LPCTSTR lpName

);

– lpAttribute: Use NULL to get the default Security Attributes.

– bInitialOwner: Set to TRUE if you want the thread that called

CreateMutex() to own the mutex.

– lpName:Any thread or process can refer to this mutex by name

• a Mutex has a reference count. You should call CloseHandle()

– CreateMutex Reference Count++

– CloseHandle Reference Count–

Opening Mutex

HANDLE OpenMutex(

DWORD dwDesiredAccess, // access

BOOL bInheritHandle, // inheritance option

LPCTSTR lpName // object name );

– dwDesiredAccess :Specifies the requested access to the mutex.

– bInheritHandle : Specifies whether the returned handle is

inheritable.

– lpName: Name to access Mutex.

– Mutex has a reference count. You should call CloseHandle()

• Locking a Mutex

– To acquire ownership of the mutex, use one of the Win32

Wait….() functions.

– If a thread waits on a non-signaled mutex then the

thread will block.

– A Mutex is signaled when no thread owns it.

– Scenario (textbook p.87 side effect)

BOOL ReleaseMutex( HANDLE hMutex );

- a thread releases ownship of the mutex by calling

ReleaseMutex().

• Handling Abandoned Mutexes

– If a thread that owns a mutex exits without calling

ReleaseMutex(), the mutex is not destroyed.

– Mutex -> unowned, nonsignaled

– Wait…() -> return : WAIT_ABANDONED_0

(~WAIT_ABANDONED_n – 1)

• Letting the Philosophers Eat

– Source

• Fixing SwapLists

Void SwapLists(struct List *list1, struct List *list2)

{

struct List *tmp_list;

HANDLE arrhandles[2];

arrHandles[0] = list1->hMutex;

arrHandles[1] = list2->hMutex;

WaitForMultipleObjects(2, arrHandles, TRUE, INFINITE);

tmp_list = list1->head;

list1->head = list2->head;

list2->head = tmp_list;

ReleaseMutex(arrHandles[0]);

ReleaseMutex(arrHandles[1]);

}

Why Have an Initial Owner?

– bInitialOwner of CreateMutex()

– It prevents a race condition.

HANDLE hMutex = CreateMutex(NULL, FALSE, “Simple Name”); <<

int result = WaitForSingleObject(hMutex, INFINITE);

– Critical Section

EnterCriticalSection(pCS)

EnterCriticalSection(pCS)

…

LeaveCriticalSection(pCS)

LeaveCriticalSection(pCS)

– Mutex

WaitforSingleObject(hMtx)

WaitforSingleObject(hMtx)

…

ReleaseMutex(hMtx)

ReleaseMutex(hMtx)

Semaphores

• They are the key ingredient in solving various

producer/consumer problems where a buffer is being read

and written at the same time.

• A semaphore in Win32 may be locked at most n times, where

n is specified when the semaphore is created.

• EX) car rental problem.

• Creating Semaphores

HANDLE Cre
ateSemaphore(

LPSECURITY_ATTRIBUTES lpAttribute,

LONG InitialCount,

LONG MaximumCount,

LPCTSTR lpName

);

– lpAttribute: Use NULL to get the default Security Attributes.

– InitialCount: Specifies an initial count for the semaphore

object(0 <= this <= MaximemCount)

– MaximumCount: Specifies the maximum count for the

semaphore object

– lpName:Any thread or process can refer to this Semaphore by name

• Acquiring Locks

– The Value of the semaphore represents the number of

resources currently available.

– You acquire a lock on a semaphore by using any of the Wait…()

– There is no concept of ownership (Semaphore has no owner)

• Several Threads can lock a semaphore at the same time

• Semaphore can be released by any thread

• Releasing Locks

– To release a lock, call ReleaseSemaphore()

– This function increments the semaphore’s value

BOOL ReleaseSemaphore(

HANDLE hSemaphore,

LONG lReleaseCount,

LPLONG lpPreviousCount

);

hSemaphore Handle to the semaphore

lReleaseCount Increment the value of the semaphore

lpPreviousCount Return the previous value of the semaphore.

Note the there is no way to get the current value.

• Why Have an Initial Count?

– Initial Value of the semaphore

– Must be greater than or equal to zero and less than

MaximumCount

– ReleaseSemaphore() can increment the count up to its

maximum

Event Objects

• The most flexible type of synchronization object in Win32 Kernel

Object ( signaled or nonsignaled)

HANDLE CreateEvent(

LPSECURITY_ATTRIBUTES lpEventAttributes,

BOOL bManualReset, // T=AutoReset, F=Manual Reset

BOOL bInitialState, // initial state; T=signaled, F=nonsignaled

LPCTSTR lpName // object name

);

SetEvent()

Memory Operation

Set the event object to the signaled state

ResetEvent()

Set the event object to the nonsignaled state

PulseEvent()

– Memoryless operation

– Manual Reset Event: Set the event object to the signaled state, wake everything

up that is currently waiting, then return to the nonsignaled state.

– Auto Reset Event: Set the event object to the signaled state, wake up a single

waiting thread (if any), return to the nonsignaled state.

Manual Reset Event Object: Set/Reset

1. Two threads are waiting for an event object (EO).

2. SetEvent(EO) will activate all threads waiting for the EO.

3. The EO will be in nonsignaled state only after the

ResetEvent()

Auto Reset Event Object: Set

1. Two threads are waiting for an event object (EO).

2. SetEvent(EO) will activate only one thread waiting for the

EO, then return to nonsignaled state

3. If no threads are waiting, the event object’s state remains

signaled,

4. Until wait (or reset()??) function.

Manual Reset Event Object: Pulse

1. Assume two threads are waiting for an event object (EO).

2. PulseEvent(EO) will activate all threads waiting for the EO,

then the EO return to the nonsignaled state.

3. If no threads are waiting, the event object’s state remains

nonsignaled

Auto Reset Event Object: Pulse

1. If no threads are waiting, the event object’s state remains

nonsignaled

2. Two threads are waiting for an event object (EO).

3. PulseEvent(EO) will activate a single thread waiting for the

EO, then the EO return to the nonsignaled state.

Event Objects: Summary

• If threads are waiting.

Activate one, then

Activate one, then — nonsignaled

Auto Reset stay nonsignaled

Activate all, then

Activate all, then Nonsignaled nonsignaled

Manual Reset stay signaled

SetEvent() ResetEvent() PulseEvent()

• If no treads are waiting.

Stay signaled, — Stay nonsignaled

Auto Reset until wait function.

Manual Reset Stay signaled Nonsignaled Stay nonsignaled

SetEvent() ResetEvent() PulseEvent()

2005-10-19 Seong Jong Choi Multithreading_CHAPTER_4-43

Summary & Questions

• PulseEvent() is an memoryless operation.

• SetEvent() is memory operation.

• Manual/auto Reset

– No threads are waiting, and current state is signaled.

What happens when PulseEvent()??

Interlocked Variables

• The simplest type of synchronization mechanism.

• Operate on a standard 32-bit long variable.

• No ability to wait

• InterlockedIncrement(LPLONG lpTarget)

• InterlockedDecrement(LPLONG lpTarget)

– These functions return a comparison against zero.

– Use these functions to maintain your object reference count.

(ex: AddRef(), Release())

Summary of Synchronization Mechanisms

• Critical Section

– Is a local object, not a kernel object

– Is fast and efficient

– Cannot be waited on more than one at a time

– Cannot determine if it was abandoned by a thread

• Mutex

– Is a kernel object

– Generates an ‘abandoned’ error if the owning thread

terminates

– Can be used in Wait…() calls

– Is Named, and can be opened across processes.

– Can only be released by the thread that owns it

• Semaphore

– Is a kernel object

– Has no owner

– Is Nameed

– Can be released by any thread

• Event Object

– Is a kernel object

– Is completely under program control

– Is good for designing new synchronization objects

– Does not queue up wake-up requests

– Is Named

• Interlocked Variable

– Useful for reference counting

VC++ FAQ’s And Interview Questions and Answers

1. The message loop calls GetMessage(), which looks in your message queue. If the message queue is empty your program basically stops and waits for one (it Blocks).

2. When an event occures causing a message to be added to the queue (for example the system registers a mouse click) GetMessages() returns a positive value indicating there is a message to be processed, and that it has filled in the members of the MSG structure we passed it. It returns 0 if it hits WM_QUIT, and a negative value if an error occured.

3. We take the message (in the Msg variable) and pass it to TranslateMessage(), this does a bit of additional processing, translating virtual key messages into character messages. This step is actually optional, but certain things won’t work if it’s not there.

4. Once that’s done we pass the message to DispatchMessage(). What DispatchMessage() does is take the message, checks which window it is for and then looks up the Window Procedure for the window. It then calls that procedure, sending as parameters the handle of the window, the message, and wParam and lParam.

5. In your window procedure you check the message and it’s parameters, and do whatever you want with them! If you aren’t handling the specific message, you almost always call DefWindowProc() which will perform the default actions for you (which often means it does nothing).

6. Once you have finished processing the message, your windows procedure returns, DispatchMessage() returns, and we go back to the beginning of the loop.
This is a very important concept for windows programs. Your window procedure is not magically called by the system, in effect you call it yourself indirectly by calling DispatchMessage(). If you wanted, you could use GetWindowLong() on the window handle that the message is destined for to look up the window’s procedure and call it directly!

while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
WNDPROC fWndProc = (WNDPROC)GetWindowLong(Msg.hwnd, GWL_WNDPROC);
fWndProc(Msg.hwnd, Msg.message, Msg.wParam, Msg.lParam);
}

I tried this with the previous example code, and it does work, however there are various issues such as Unicode/ANSI translation, calling timer callbacks and so forth that this method will not account for, and very likely will break all but trivial applications. So do it to try it, but don’t do it in real code Notice that we use GetWindowLong() to retreive the window procedure associated with the window. Why don’t we just call our WndProc() directly? Well our message loop is responsible for ALL of the windows in our program, this
includes things like buttons and list boxes that have their own window procedures, so we need to make sure that we call the right procedure for the window. Since more than one window can use the same window procedure, the first parameter (the handle to the window) is used to tell the window procedure which window the message is intended for. As you can see, your application spends the majority of it’s time spinning round and round in this message loop, where you joyfully send out messages to the happy windows that will process them. But what do you do when you want your program to exit? Since we’re using a while() loop, if GetMessage() were to return FALSE (aka 0), the loop would end and we would reach the end of our WinMain() thus exiting the program. This is exactly what PostQuitMessage() accomplishes. It places a WM_QUIT message into the queue, and instead of returning a
positive value, GetMessage() fills in the Msg structure and returns 0. At this point, the wParam member of Msg contains the value that you passed to PostQuitMessage() and you can either ignore it, or return it from WinMain() which will then be used as the exit code when the process terminates.

IMPORTANT: GetMessage() will return -1 if it encounters an error. Make sure you remember this, or it will catch you out at some point… even though GetMessage() is defined as returning a BOOL, it can return values other than TRUE or FALSE, since BOOL is defined as UINT (unsigned int). The following are examples of code that may seem to work, but will not process certian conditions correctly:

while(GetMessage(&Msg, NULL, 0, 0))
while(GetMessage(&Msg, NULL, 0, 0) != 0)
while(GetMessage(&Msg, NULL, 0, 0) == T RUE)

The above are all wrong! It may be of note that I used to use the first of these throughout the tutorial, since as I just mentioned, it works fine as long as GetMessage() never fails, which when your code is correct it won’t. However I failed to take into consideration that if you’re reading this, your code probably won’t be correct a lot of the time, and GetMessage() will fail at some point I’ve gone through and corrected this, but forgive me if I’ve missed a few spots.

while(GetMessage(&Msg, NULL, 0, 0) > 0)

This, or code that has the same effect should always be used. I hope you now have a better understanding of the windows message loop, if not, do not fear, things will make more
sense once you have been using them for a while.

VC++ FAQ’s And Interview Questions and Answers