Two mutex, how to form an infinite loop?Fan questions must be arranged.
How can two threads, two mutex deadlock?
The program flow chart is as follows:
As shown above:
- At t0, the main thread creates a child thread and initializes mutex1 and mutex2.
- At t1, the main thread applied for mutex1 and the child thread applied for mutex2.
- At t2, both the main thread and the child thread sleep for 1 second to prevent the thread that obtains the time slice first from directly applying for another mutex, leading to the program exit directly.
- At t3, the main thread and the child thread both try to acquire the mutex from the other thread, but the other thread has no time to release its own lock.
- At t4, both the main thread and the subline go to sleep.
【 Note 】 In order to ensure that the main thread and child thread can obtain mutex1 and mutex2 locks respectively, they must sleep for 1 second after obtaining the lock, otherwise, the main thread will still have a certain time slice after creating the child thread, the main thread will apply for mutex2 lock, unable to form deadlock.
The source code is as follows
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include
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;
}
Copy the code
Compile operation
From the execution result, it can be seen that the main thread and the child thread have obtained mutex1 and mutex2 respectively, and after sleep 1 second, they both want to apply mutex2 and mutex1 respectively, but neither of them want to release the lock in their hands. The lock has formed a deadlock, and the program has been in hibernation.
Check the thread of the process
View the process ID, which is 4204Check the ids of the threads created by the process: 4204 and 4205.More embedded Linux knowledge please pay attention to the public number: a Linux