Object Hierarchy:

GLib.Mutex GLib.Mutex GLib.Mutex


[ Version ( since = "2.32" ) ]
[ CCode ( destroy_function = "g_mutex_clear" , has_type_id = false , lvalue_access = false ) ]
public struct Mutex

The 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:

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;
It is easy to see that this won't work in a multi-threaded application. There current_number must be protected against shared access. A Mutex can be used as a solution to this problem:
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;
Notice that the 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 Mutex is placed in other contexts (eg: embedded in a struct) then it must be explicitly initialised using Mutex.

A Mutex should only be accessed via g_mutex_ functions.

Example: Mutex:

public static int main (string[] args) {
if (Thread.supported () == false) {
print ("Threads are not supported.\n");
return 0;

// Mutex used to protect data:
Mutex mutex = Mutex ();

// Shared Data: Must not be accessed by more than one thread at once
int MAX = 100;
int thread_id = 0;
int shared = 0;

ThreadFunc<bool> worker_func = () => {
// Enter the critical section: Other threads are locked out
// until unlock () is called
mutex.lock ();
int id = thread_id;
mutex.unlock ();
// Leave the critical section

while (shared < MAX) {
// ...

mutex.lock ();
int tmp = shared;
print ("t%d = %d\n", id, tmp);
mutex.unlock ();

// ...
Thread.usleep (10000);
return true;

Thread<bool> thread1 = new Thread<bool> ("thread-1", worker_func);
Thread<bool> thread2 = new Thread<bool> ("thread-2", worker_func);

thread1.join ();
thread2.join ();

return 0;

valac --target-glib 2.32 --pkg glib-2.0 GLib.Mutex.vala

Namespace: GLib
Package: glib-2.0


Creation methods: