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:

  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;
  }

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:

  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;
  }

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;
		thread_id++;
		mutex.unlock ();
		// Leave the critical section

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

			mutex.lock ();
			int tmp = shared;
			print ("t%d = %d\n", id, tmp);
			shared++;
			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