RecMutex

The GRecMutex struct is an opaque data structure to represent a recursive mutex.

It is similar to a Mutex with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked.

If a RecMutex is allocated in static storage then it can be used without initialisation. Otherwise, you should call RecMutex on it and g_rec_mutex_clear when done.

A GRecMutex should only be accessed with the g_rec_mutex_ functions.

Example: RecMutex, nested critical sections:

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

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

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

	Func<string> inc_counter = (name) => {
		// Enter the critical section: Other threads are locked out
		// until unlock () is called
		// RecMutex allows us to nest critical section without deadlock.
		mutex.lock ();
		int tmp = shared;
		print ("%s=%d\n", name, tmp);
		shared++;
		mutex.unlock ();
		// Leave the critical section
	};

	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 ();
			inc_counter ("t%d".printf (id));
			mutex.unlock ();

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

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

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

	return 0;
}

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