Sets our main struct and passes it to the parent class.
Frees the resources allocated to a lock with g_rw_lock_init().
Get the main Gtk struct
the main Gtk struct as a void*
Initializes a #GRWLock so that it can be used.
Obtain a read lock on @rw_lock. If another thread currently holds the write lock on @rw_lock or blocks waiting for it, the current thread will block. Read locks can be taken recursively.
Tries to obtain a read lock on @rw_lock and returns %TRUE if the read lock was successfully obtained. Otherwise it returns %FALSE.
Release a read lock on @rw_lock.
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.
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.
Release a write lock on @rw_lock.
The GRWLock struct is an opaque data structure to represent a reader-writer lock. It is similar to a #GMutex 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()).
Here is an example for an array with access functions: |[<!-- language="C" --> GRWLock lock; GPtrArray *array;
gpointer 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; }
void 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); } ]| This 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 #GRWLock 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.