Thread Synchronization Classes

Download source files - 2 Kb

This article describes a set of classes that are used to perform synchronization between different threads. The class diagram below should explain the idea:

At the root, there is a TSynchroBase class that has 2 abstract virtual methods: (1) DoLock() and (2) DoUnlock(). These 2 methods are implemented in derived classes because they contain selected synchronization method specific code.

Two concrete classes are supplied:

1. TSynchroMutex that uses a mutex for synchronization.
2. TSynchroCriticalSection that uses a critical section for synchronization.

However, additional classes may be implemented (for example, a class that uses events or semaphores).

When synchronization is used in the application, one has to take care that the synchronization object is unlocked once the thread that took ownership of the synchronization object is finished with it. If this is not done, other threads will be blocked. This can be difficult and error prone in a complex function where there is more then one exit point from a function. A simple solution is to move the protected code to a function and this function is called after taking ownership of the synchronization object. After the function, the synchronization object is released. This is illustrated in the following sample code.

Error prone example:

...
Lock()
... 
// Code block with multiple exit points
if (...)
{ 
   Unlock(); 
   return; 
} 
...
Unlock();

Better solution:

...
Lock();
Function();	// Function with multiple exit points
Unlock();
...

In the first example it is easy to forget a single Unlock() which is a logical error that may block other threads since they cannot take ownership of the synchronization object.

The second example clutters the code with unnecessary functions.

TSynchroTransient class is designed to solve this problem. It takes a pointer to a synchronization object in a constructor and immediately takes ownership of the synchronization object. It will automatically release the synchronization object in its destructor.

TSynchroMutex g_Synchro;

function()
{
    TSynchroTransient synchro(&g_Synchro);
	if (synchro.IsLocked())
	{
	    // Do whatever
	}
}

For this to function properly, it is necessary that the TSynchroTransient object is created on the stack -- it will be automatically destroyed when the function exits. The IsLocked() check is needed only if you use a synchronization method that may fail (for example, mutex). If you use critical sections, it is not necessary to call this function since entering critical section blocks until is succeeds.