GLib.Mutex
Description: Reference for GLib.Mutex

### Struct

# GLibMutex

#### Description [src]

    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.