Qu'est-ce qu'une situation de blocage à Java et comment peut-elle être empêchée?

L'impasse se produit en Java lorsque deux fils ou plus bloquent définitivement, attendant les ressources de l'autre les uns par les autres, formant une dépendance circulaire. 1. Évitez les serrures imbriquées, acquièrez toujours des verrous dans un ordre cohérent et empêchez l'attente de la boucle; 2. Utilisez Trylock () avec le délai d'expiration pour faire sortir activement le fil lorsqu'il ne peut pas acquérir le verrou; 3. Réduisez la portée de la serrure et donnez la priorité à l'utilisation de structures sans verrouillage telles que lamale concurrente et atomicInteger; 4. Utilisez des outils tels que JSTACK et VisualVM pour détecter les impasses et combiner des tests unitaires et des outils d'analyse statique pour découvrir des problèmes potentiels; 5. Refactor le code pour éviter de tenir plusieurs verrous en même temps, comme l'utilisation de BlockingQueue pour la communication inter-thread plutôt que de partager l'état. En suivant ces stratégies, les impasses peuvent être effectivement empêchées et la stabilité des programmes multithreads peut être assurée.

Une impasse en Java se produit lorsque deux threads ou plus sont bloqués pour toujours, chacun attendant une ressource qu'un autre thread contient, créant un cycle de dépendances. Cela se produit généralement dans les programmes multithread lorsque les threads acquièrent des verrous sur plusieurs objets et finissent par attendre les uns les autres pour libérer ces verrous.

Comment se produit l'impasse - un exemple simple

Imaginez deux threads, Thread A et Thread B et deux objets, OBJ1 et OBJ2:

• Le thread A tient un verrou sur Obj1 et souhaite acquérir un verrou sur OBJ2.
• Le thread B détient une serrure sur OBJ2 et souhaite acquérir un verrou sur OBJ1.

Maintenant, les deux threads s'attendent à libérer le verrou - et non plus. Ceci est une impasse classique.

Voici un extrait de code qui peut conduire à une impasse:

 classe publique daadlockexample {
    objet statique obj1 = nouveau objet ();
    objet statique obj2 = nouveau objet ();

    public static void main (String [] args) {
        Thread t1 = nouveau thread (() -> {
            synchronisé (obj1) {
                System.out.println ("Thread 1: Holding Lock sur Obj1 ...");
                essayez {thread.sleep (100); } catch (InterruptedException e) {}
                System.out.println ("Thread 1: en attente d'OBJ2 ...");
                synchronisé (obj2) {
                    System.out.println ("Thread 1: OBJ2 acquis");
                }
            }
        });

        Thread t2 = nouveau thread (() -> {
            synchronisé (obj2) {
                System.out.println ("Thread 2: maintenir le verrouillage sur Obj2 ...");
                essayez {thread.sleep (100); } catch (InterruptedException e) {}
                System.out.println ("Thread 2: En attente d'OBJ1 ...");
                synchronisé (obj1) {
                    System.out.println ("Thread 2: OBJ1 acquis");
                }
            }
        });

        t1.start ();
        t2.start ();
    }
}

Ce code peut pendre indéfiniment - une impasse.

Comment empêcher l'impasse en Java

La prévention de l'impasse implique une conception minutieuse de la façon dont les threads acquièrent et relâchent les verrous. Voici les principales stratégies:

1. Évitez les serrures imbriquées (commande de verrouillage)

Acquérir toujours des verrous dans un ordre cohérent et prédéfini. Si tous les threads demandent plusieurs verrous dans le même ordre, les conditions d'attente circulaires ne peuvent pas se produire.

Par exemple:

 // Acquérir toujours OBJ1 d'abord, puis obj2
synchronisé (obj1) {
    synchronisé (obj2) {
        // fonctionne
    }
}

Si chaque thread suit cet ordre, le thread B ne maintiendra pas OBJ2 en attendant OBJ1 si le thread A contient déjà OBJ1.

2. Utilisez le temps mort lorsque vous essayez d'acquérir un verrouillage

Utilisez tryLock() de java.util.concurrent.locks.ReentrantLock avec un délai d'expiration au lieu de synchronized . Cela permet à un fil d'abandonner après un certain temps, brisant le cycle de l'impasse.

 ReentrantLock Lock1 = new reentrantLock ();
ReentrantLock Lock2 = new reentrantLock ();

// dans le fil
if (lock1.trylock (1000, timeunit.milliseconds)) {
    essayer {
        if (lock2.trylock (1000, timeunit.milliseconds)) {
            essayer {
                // fonctionne
            } enfin {
                lock2.unlock ();
            }
        }
    } enfin {
        lock1.unlock ();
    }
}

Si une serrure ne peut pas être acquise dans le délai d'attente, le fil recule - éviter une attente indéfinie.

3. Minimiser la portée de verrouillage et utiliser des structures sans verrouillage

• Verrouillez uniquement la section critique minimale.
• Utilisez des structures de données simultanées comme ConcurrentHashMap , CopyOnWriteArrayList ou des classes atomiques ( AtomicInteger , etc.) lorsque cela est possible pour réduire le besoin de verrouillage explicite.

4. Utilisez des analyses et des outils statiques

• Utilisez des outils comme JSTACK , JConsole ou VisualVM pour détecter les impasses à l'exécution.
• JSTACK peut imprimer des vidages de threads montrant quels threads sont bloqués et sur quels moniteurs.
• Écrivez des tests unitaires pour du code simultané et utilisez des outils tels que Findbugs / SpotBugs pour détecter les problèmes de blocage potentiels.

5. Conception pour éviter de tenir plusieurs serrures

Si possible, restructurez votre code afin que les threads n'aient pas besoin de maintenir plusieurs verrous en même temps. Par exemple:

• Utilisez des modèles de transfert de messages (par exemple, BlockingQueue ) au lieu de l'état partagé.
• Réduire les données mutables partagées.

Résumé

Dedlock est un problème grave dans les applications Java multithread, mais elle peut être évitée avec une conception appropriée. Les techniques de prévention clés comprennent:

• Toujours acquérir des verrous dans un ordre cohérent.
• Utilisation tryLock() avec des délais d'attente.
• Réduire la portée des serrures et éviter la synchronisation imbriquée.
• Préférant des collections concomitantes et des variables atomiques.
• Surveillance et test des impasses pendant le développement.

Bien que vous ne puissiez pas toujours éliminer complètement le risque, le suivi de ces pratiques rend les impasses beaucoup moins probables.

Fondamentalement, il s'agit de discipline dans la façon dont vous gérez l'accès aux ressources partagées.

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!