Modèle de mémoire Java et blocage : compréhension approfondie des problèmes de blocage dans la programmation simultanée

L'éditeur php Youzi analysera en détail le modèle de mémoire Java et les problèmes de blocage, et explorera en profondeur les principaux défis de la programmation simultanée. Comprendre et maîtriser les causes et les solutions des blocages est crucial pour améliorer vos compétences en programmation simultanée. Examinons-le ensemble et résolvons ce problème courant mais difficile.

Dead lock est un problème courant dans la programmation simultanée, qui se produit lorsque deux threads ou plus s'attendent l'un l'autre pour libérer le verrou. Lorsqu'un thread détient un verrou, si un autre thread tente également d'acquérir le verrou, le deuxième thread sera bloqué. Si deux threads détiennent des verrous dont l'un l'autre a besoin, un blocage se produit.

Afin de résoudre le problème de blocage, vous pouvez utiliser les méthodes suivantes :

• Évitez les blocages : essayez d'éviter de créer des conditions de blocage dans votre code. Par exemple, n'utilisez pas plusieurs verrous sur le même objet et ne demandez pas à un thread d'attendre qu'un autre thread libère le verrou.
• Utiliser le délai d'expiration du verrouillage : spécifiez un délai d'expiration lors de l'acquisition du verrou. Si le verrou ne peut pas être acquis dans le délai imparti, le thread lèvera une exception et poursuivra l'exécution.
• Utiliser des interruptions : lorsqu'un thread attend qu'un autre thread libère le verrou, il peut envoyer un signal d'interruption au thread en attente. Si le thread reçoit un signal d'interruption, une exception InterruptedException est levée et l'exécution continue.

Voici un exemple de code qui démontre une impasse :

public class DeadlockExample {

private static Object lock1 = new Object();
private static Object lock2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println("Thread 1 acquired both locks");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (lock2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println("Thread 2 acquired both locks");
}
}
});

thread1.start();
thread2.start();
}
}

Dans cet exemple de code, deux threads tentent d'acquérir deux verrous en même temps. Le thread 1 acquiert d’abord le verrou 1, puis tente d’acquérir le verrou 2. Le thread 2 acquiert d'abord le verrou 2, puis tente d'acquérir le verrou 1. Un blocage se produit parce que les deux threads détiennent des verrous dont l'autre a besoin.

Afin de résoudre ce problème de blocage, le code peut être modifié comme suit :

public class DeadlockExample {

private static Object lock1 = new Object();
private static Object lock2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println("Thread 1 acquired both locks");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (lock2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println("Thread 2 acquired both locks");
}
}
});

thread1.start();
thread2.start();

thread1.join();
thread2.join();
}
}

Dans ce code modifié, nous utilisons la méthode join() pour attendre la fin de l'exécution du thread. De cette façon, vous pouvez vous assurer que le thread 1 acquiert le verrou 2 après avoir acquis le verrou 1 et que le thread 2 acquiert le verrou 1 après avoir acquis le verrou 2. De cette façon, il n’y aura pas de blocage.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!