glib/org.gtkkn.bindings.glib/Mutex

Mutex

class Mutex(val glibMutexPointer: <Error class: unknown class><<Error class: unknown class>>) : ProxyInstance(source)

The #GMutex 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 #GMutex 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 #GMutex 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 #GMutex is placed in other contexts (eg: embedded in a struct) then it must be explicitly initialised using g_mutex_init().

A #GMutex should only be accessed via g_mutex_ functions.

Constructors

constructor()

Allocate a new Mutex.

constructor(scope: <Error class: unknown class>)

Allocate a new Mutex using the provided AutofreeScope.

constructor(glibMutexPointer: <Error class: unknown class><<Error class: unknown class>>)

Types

object Companion

Properties

glibMutexPointer

val glibMutexPointer: <Error class: unknown class><<Error class: unknown class>>

open override val handle: <Error class: unknown class>

Functions

open override fun addCleaner(cleaner: <Error class: unknown class>): Boolean

Registers a cleaner to be executed when this proxy object is garbage collected.

fun clear()

Frees the resources allocated to a mutex with g_mutex_init().

open operator override fun equals(other: Any?): Boolean

Compare two proxy instances for equality. This will compare both the type of the instances, and their memory addresses.

fun free()

This is deprecated since version 2.32.

getSimpleNameWithHandle

open fun getSimpleNameWithHandle(): String

open override fun hashCode(): Int

fun init()

Initializes a #GMutex so that it can be used.

fun lock()

Locks @mutex. If @mutex is already locked by another thread, the current thread will block until @mutex is unlocked by the other thread.

open override fun removeCleaner(cleaner: <Error class: unknown class>): Boolean

Removes a previously registered cleaner from this proxy object.

fun trylock(): Boolean

Tries to lock @mutex. If @mutex is already locked by another thread, it immediately returns false. Otherwise it locks @mutex and returns true.

fun unlock()

Unlocks @mutex. If another thread is blocked in a g_mutex_lock() call for @mutex, it will become unblocked and can lock @mutex itself.