The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a glib.Mutex in that it allows multiple threads to coordinate access to a shared resource.

The difference to a mutex is that a reader-writer lock discriminates between read-only ('reader') and full ('writer') access. While only one thread at a time is allowed write access (by holding the 'writer' lock via g_rw_lock_writer_lock()), multiple threads can gain simultaneous read-only access (by holding the 'reader' lock via g_rw_lock_reader_lock()).

It is unspecified whether readers or writers have priority in acquiring the lock when a reader already holds the lock and a writer is queued to acquire it.

Here is an example for an array with access functions:

GRWLock lock;
GPtrArray *array;

my_array_get (guint index)
gpointer retval = NULL;

if (!array)
return NULL;

g_rw_lock_reader_lock (&lock);
if (index < array->len)
retval = g_ptr_array_index (array, index);
g_rw_lock_reader_unlock (&lock);

return retval;

my_array_set (guint index, gpointer data)
g_rw_lock_writer_lock (&lock);

if (!array)
array = g_ptr_array_new ();

if (index >= array->len)
g_ptr_array_set_size (array, index+1);
g_ptr_array_index (array, index) = data;

g_rw_lock_writer_unlock (&lock);

his example shows an array which can be accessed by many readers (the my_array_get() function) simultaneously, whereas the writers (the my_array_set() function) will only be allowed one at a time and only if no readers currently access the array. This is because of the potentially dangerous resizing of the array. Using these functions is fully multi-thread safe now.

If a glib.RWLock is allocated in static storage then it can be used without initialisation. Otherwise, you should call g_rw_lock_init() on it and g_rw_lock_clear() when done.

A GRWLock should only be accessed with the g_rw_lock_ functions.


this(GRWLock* gRWLock, bool ownedRef)

Sets our main struct and passes it to the parent class.



void clear()

Frees the resources allocated to a lock with g_rw_lock_init().

GRWLock* getRWLockStruct(bool transferOwnership)

Get the main Gtk struct

void* getStruct()

the main Gtk struct as a void*

void init()

Initializes a glib.RWLock so that it can be used.

void readerLock()

Obtain a read lock on rw_lock. If another thread currently holds the write lock on rw_lock, the current thread will block. If another thread does not hold the write lock, but is waiting for it, it is implementation defined whether the reader or writer will block. Read locks can be taken recursively.

bool readerTrylock()

Tries to obtain a read lock on rw_lock and returns TRUE if the read lock was successfully obtained. Otherwise it returns FALSE.

void readerUnlock()

Release a read lock on rw_lock.

void writerLock()

Obtain a write lock on rw_lock. If any thread already holds a read or write lock on rw_lock, the current thread will block until all other threads have dropped their locks on rw_lock.

bool writerTrylock()

Tries to obtain a write lock on rw_lock. If any other thread holds a read or write lock on rw_lock, it immediately returns FALSE. Otherwise it locks rw_lock and returns TRUE.

void writerUnlock()

Release a write lock on rw_lock.


GRWLock* gRWLock;

the main Gtk struct