Mutex

The glib.Mutex struct is an opaque data structure to represent a mutex (mutual exclusion). It can be used to protect data against shared access.

Take for example the following function:

int
give_me_next_number (void)
{
static int current_number = 0;

// now do a very complicated calculation to calculate the new
// number, this might for example be a random number generator
current_number = calc_next_number (current_number);

return current_number;
}

t is easy to see that this won't work in a multi-threaded application. There current_number must be protected against shared access. A glib.Mutex can be used as a solution to this problem:

int
give_me_next_number (void)
{
static GMutex mutex;
static int current_number = 0;
int ret_val;

g_mutex_lock (&mutex);
ret_val = current_number = calc_next_number (current_number);
g_mutex_unlock (&mutex);

return ret_val;
}

otice that the glib.Mutex is not initialised to any particular value. Its placement in static storage ensures that it will be initialised to all-zeros, which is appropriate.

If a glib.Mutex is placed in other contexts (eg: embedded in a struct) then it must be explicitly initialised using Mutex.init.

A glib.Mutex should only be accessed via g_mutex_ functions.

class Mutex {

protected

GMutex* gMutex;

protected

bool ownedRef;

GMutex* getMutexStruct(bool transferOwnership);

void* getStruct();

this(GMutex* gMutex, bool ownedRef);

}

Constructors

this this(GMutex* gMutex, bool ownedRef): Sets our main struct and passes it to the parent class.

Members

Functions

clear void clear(): Frees the resources allocated to a mutex with Mutex.init.
getMutexStruct GMutex* getMutexStruct(bool transferOwnership): Get the main Gtk struct
getStruct void* getStruct(): the main Gtk struct as a void*
init void init(): Initializes a glib.Mutex so that it can be used.
lock void lock(): Locks mutex. If mutex is already locked by another thread, the current thread will block until mutex is unlocked by the other thread.
trylock bool trylock(): Tries to lock mutex. If mutex is already locked by another thread, it immediately returns FALSE. Otherwise it locks mutex and returns TRUE.
unlock void unlock(): Unlocks mutex. If another thread is blocked in a Mutex.lock call for mutex, it will become unblocked and can lock mutex itself.

Variables

gMutex GMutex* gMutex;: the main Gtk struct

glib Mutex classes

Mutex