Two threads, two mutexes, how can a dead loop be formed?

[[351971]]

Fans’ questions must be arranged.

How can two threads and two mutexes deadlock?

The program flow chart is as follows:

Program flow chart

As shown in the figure above:

1. At time t0, the main thread creates a child thread and initializes the mutexes mutex1 and mutex2;
2. At time t1, the main thread applies for mutex1 and the child thread applies for mutex2;
3. At time t2, both the main thread and the child thread sleep for 1 second to prevent the thread that gets the time slice first from directly applying for another mutex, causing the program to exit directly;
4. At t3, both the main thread and the child thread want to acquire the mutex lock held by the other party, but neither party has time to release the lock in their own hand;
5. At t4, both the main thread and the sub-thread go into sleep.

[Note] To ensure that the main thread and child thread can obtain the locks mutex1 and mutex2 respectively, each thread must sleep for 1 second after obtaining the lock. Otherwise, after the child thread is created, the main thread still has a certain time slice, and the main thread will apply for the lock mutex2, and a deadlock cannot be formed.

Deadlock

The source code is as follows

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h> 
 
 unsigned int value1, value2, count ;
 pthread_mutex_t mutex1,mutex2;
 void * function (void *arg); 
 
 
 void * function (void *arg)
 {
 pthread_mutex_lock(&mutex2);
 printf( "new thread get mutex2\n" );
 sleep(1);
 pthread_mutex_lock(&mutex1);
 printf( "new thread get mutex1\n" ); 
  
  
 pthread_mutex_unlock(&mutex1);
 printf( "new thread release mutex1\n" );
 pthread_mutex_unlock(&mutex2);
 printf( "new thread release mutex2\n" );
 return    NULL ;
 } 
 
 int main( int argc, char *argv[])
 {
 pthread_t a_thread; 
          
 if (pthread_mutex_init(&mutex1, NULL ) < 0)
 {
  perror( "fail to mutex_init" );
 exit(-1);
 }
  if (pthread_mutex_init(&mutex2, NULL ) < 0)
 {
  perror( "fail to mutex_init" );
 exit(-1);
 }
 if (pthread_create(&a_thread, NULL , function , NULL ) < 0)
 {
  perror( "fail to pthread_create" );
 exit(-1);
 }
 while ( 1 )
 {
        pthread_mutex_lock(&mutex1);
  printf( "main thread get mutex1\n" );
 sleep(1);
        pthread_mutex_lock(&mutex2);
  printf( "main thread get mutex2\n" );
        pthread_mutex_unlock(&mutex2);
  printf( "main thread release mutex2\n" );
        pthread_mutex_unlock(&mutex1);
  printf( "main thread release mutex1\n" );
 }
 return 0;
 }
 Compile and run

Compile and run

From the execution results, we can judge that the main thread and the child thread obtained the mutex locks mutex1 and mutex2 respectively. After sleeping for 1 second, they both wanted to apply for mutex2 and mutex1 respectively, but neither side wanted to release the locks in their hands. The locks have formed a deadlock, and the program has been in a dormant state.

Check the threads of the process

Check the process ID, which is 4204

Check the thread IDs created by the process: 4204, 4205.

This article is reprinted from the WeChat public account "Yikou Linux", which can be followed through the following QR code. To reprint this article, please contact Yikou Linux public account.