Struct

GLibMutex

Description 

union GMutex {
  /* No available fields */
}

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.

Functions

g_mutex_new

Allocates and initializes a new GMutex.

deprecated: 2.32 

Instance methods

g_mutex_clear

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

since: 2.32

g_mutex_free

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

deprecated: 2.32 

g_mutex_init

Initializes a GMutex so that it can be used.

since: 2.32

g_mutex_lock

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

g_mutex_trylock

Tries to lock mutex. If mutex is already locked by another thread, it immediately returns FALSE. Otherwise it locks mutex and returns TRUE.

g_mutex_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.