---

Mutex (Mutual Exclusive) locks

---

• Mutex Locks: Theory
  • A mutex lock variable has 2 values (states)
    • Unlocked
    • Locked

  • A mutex lock is a synchronization object with 2 operations:

    Lock If the mutex lock is in the unlocked state, the lock will complete (and the thread continues with the next instruction following the lock command). The value (state) of the mutex lock is changed to locked If the mutex lock is in the locked state, the thread that executes the lock command will block (it stops execution) until the value (state) of the mutex lock becomes unlocked (When the state of the mutex lock does become unlocked, the lock command will complete and change the state of the mutex lock to locked) Unlock If the mutex lock is in the locked state, the state is changed to unlocked If the mutex lock is in the unlocked state, this operation has no effect. The mutex lock can ONLY be unlocked by the thread had previously locked the mutex !!!

  ---

• Mutex Locks in PThreads
  • Defining a mutex lock variable in Pthreads:

    pthread_mutex_t x;

    ---

    ---

    ---

  • Initializing a mutex variable:

    After defining the mutex lock variable, you must initialized it using the following function:

    int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr );

    • mutex: is the mutex lock that you want to initialize (pass the address !)

    • attr: is the set of initial property of the mutex lock.

    The most common mutex lock is one where the lock is initially in the unlock.

    This kind of mutex lock is created using the (default) attribute null:

    Example: initialize a mutex variable pthread_mutex_t x; /* Define a mutex lock "x" */ pthread_mutex_init(&x, NULL); /* Initialize "x" */

    ---

    ---

    ---

  • Locking a mutex:

    int pthread_mutex_lock(pthread_mutex_t *mutex);

    Example: pthread_mutex_t x; pthread_mutex_init(&x, NULL); ... pthread_mutex_lock(&x);

    • NOTE: although it is possible for pthread_mutex_lock() (and other thread locking functions) to return an error code (see "man pthread_mutex_lock"), it is so rare that we rarely check the return code...

    ---

    ---

    ---

  • Unlocking a mutex: (remember: only the thread that has locked the mutex can unlock it !)

    int pthread_mutex_unlock(pthread_mutex_t *mutex);

    Example: pthread_mutex_unlock(&x);

  ---

  ---

• Using mutex lock to synchronize access of shared variables
  • The jargon "synchronize something" (like synchronize access) means to organize (through timing) the different things (access operations) in such a way that there is no conflict.

  • A common usage of mutex is to synchronize updates of shared (global) variables

    Whenever a thread want to update a shared variable, it must enclose the operation between a "lock - unlock" pair.

    Example:

    int N; // SHARED variable pthread_mutex_t N_mutex; // Mutex controlling access to N void *worker(void *arg) { int i; for (i = 0; i < 10000; i = i + 1) { pthread_mutex_lock(&N_mutex); N = N + 1; pthread_mutex_unlock(&N_mutex); } }

    • Although many thread are executing simultaneously, the statement pthread_mutex_lock(&N_mutex); ensures that exactly ONE thread is sucessful in locking the mutex variable N_mutex.

      This particular thread will then be the only thread that will update the variable N, thus ensuring that N is updated sequential (one thread after another)

    • Example Program: (Mutex) --- click here        

      Compare the behavior of this program with the one that does not use MUTEX to control access to N: click here

  • NOTE:
    • Make sure you unlock a mutex after you are done with accessing the share variable(s).

      A common error in parallel programs is to forget the unlock call (especially if the call is made after many statments)... the result is deadlock - you program hangs (no progress)

    • Example Program: (Not unlocking a mutex) --- click here