glib/org.gtkkn.bindings.glib/Mutex

Mutex

class Mutex(pointer: <Error class: unknown class><<Error class: unknown class>>, cleaner: <Error class: unknown class>? = null) : ProxyInstance

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.

Skipped during bindings generation

function new: Return type Mutex is unsupported

Constructors

Mutex

constructor()

Allocate a new Mutex.

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

Allocate a new Mutex using the provided AutofreeScope.

constructor(pointer: <Error class: unknown class><<Error class: unknown class>>, cleaner: <Error class: unknown class>? = null)

Properties

glibMutexPointer

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

handle

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

Functions

clear

fun clear()

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

equals

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.

free

fun free()

Destroys a @mutex that has been created with g_mutex_new().

hashCode

open override fun hashCode(): Int

init

fun init()

Initializes a #GMutex so that it can be used.

lock

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.

trylock

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.

unlock

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.