Deadlock with Mutex Locks

Let’s see how deadlock can occur in a multithreaded Pthread program using mutex locks. The pthread_mutex_init() function initializes an unlocked mutex. Mutex locks are acquired and released using pthread_mutex_lock() and pthread_mutex_unlock(), respectively. If a thread attempts to acquire a locked mutex, the call to pthread_mutex_lock() blocks the thread until the owner of the mutex lock invokes pthread_mutex_unlock().

Two mutex locks are created in the following code example:

                                /* Create and initialize the mutex locks */

                                     pthread mutex t first mutex;

                                     pthread mutex t second mutex;

                                     pthread mutex init(&first mutex,NULL);

                                     pthread mutex init(&second mutex,NULL);

Next, two threads—thread_one and thread_two—are created, and both these threads have access to both mutex locks. thread_one and thread_two run in the functions do_work_one() and do_work_two(), respectively, as shown below:                                            /* thread one runs in this function */

                                           void *do work one(void *param) {

                                                     pthread mutex lock(&first mutex);

                                                     pthread mutex lock(&second mutex);

                                           /**

                                            *  Do some work

                                            */

                                           pthread mutex unlock(&second mutex);

                                           pthread mutex unlock(&first mutex);

                                           pthread exit(0);

                                           }

                                          /* thread two runs in this function  */

                                          void *do work two(void *param) {

                                                     pthread mutex lock(&second mutex);

                                                     pthread mutex lock(&first mutex);

                                                     /**

                                                     * Do some work

                                                     */

                                                     pthread mutex unlock(&first mutex);

                                                     pthread mutex unlock(&second mutex);

                                                     pthread exit(0);

                                           }

In this example, thread one attempts to acquire the mutex locks in the order

(1) first_mutex,

(2) second_mutex,

while thread two attempts to acquire the mutex locks in the order

(1) second_mutex,

(2) first_mutex.

Deadlock is possible if thread_one acquires first mutex while thread two acquires second mutex. Note that, even though deadlock  is possible, it will not occur if thread one can acquire and release the mutex locks for first_mutex and second_mutex before thread_two attempts to acquire the locks. And, of course, the order in which the threads run depends on how they are scheduled by the CPU scheduler. This example illustrates a problem with handling deadlocks: it is difficult to identify and test for deadlocks that may occur only under certain scheduling circumstances.