La clé pour éviter les impasses est de comprendre les conditions de leur occurrence et d'adopter des stratégies appropriées pour éviter l'évasion, qui comprend les 4 méthodes suivantes: 1. Unifier l'ordre de verrouillage pour garantir que tous les threads acquièrent des verrous dans le même ordre, évitant ainsi la boucle d'attente; 2. Utilisez Explicit Lock ReentrantLock et définissez l'heure du délai d'expiration, essayez d'acquérir des verrouillage dans la méthode Trylock () pour éviter l'attente indéfinie; 3. Réduire la granularité et la portée de l'utilisation de la serrure, uniquement les pièces clés, essayez d'utiliser des variables locales et des classes de collecte simultanées pour réduire la probabilité de conflit; 4. Utilisez des outils tels que JSTACK, VisualVM, etc. pour détecter les blocs de blocage potentiels, et identifier rapidement et résoudre des problèmes de blocage des threads.

Dans la programmation multithread Java, l'impasse est un problème commun mais facilement négligé. Cela se produit généralement lorsque plusieurs threads attendent les ressources de l'autre, ce qui entra?ne le collaboration du programme et incapable de continuer à exécuter. La clé pour éviter les blocages est de comprendre les conditions dans lesquelles ils se produisent et d'adopter des stratégies appropriées pour contourner.

1. évitez le verrouillage imbriqué (commande de verrouillage)

La plupart des problèmes de blocage découlent de plusieurs threads acquérant plusieurs verrous dans différents ordres. Par exemple, si le thread A acquiert le verrouillage 1 d'abord, puis le verrouillage 2, et que le fil B acquiert le verrouillage 2 d'abord puis le verrouillage 1, une impasse peut se produire.

Solution: ordre de verrouillage unifié

Tant que tous les threads acquièrent des verrous dans le même ordre, cette situation d'attente de boucle peut être effectivement évitée. Par exemple, il est stipulé que la serrure avec un nombre plus petit est toujours acquise en premier, puis le verrou avec un nombre plus grand est obtenu.

Par exemple:

 // Fil 1
synchronisé (locka) {
    synchronisé (LockB) {
        // faire quelque chose
    }
}

// Thread 2 (s'il est également dans le même ordre, il n'y aura pas de conflit)
synchronisé (locka) {
    synchronisé (LockB) {
        // faire autre chose
    }
}

De cette fa?on, les deux fils ne connaissent pas les wates croisées, évitant ainsi les blocs de bloces.

2. Utilisez un verrouillage explicite et définissez le délai d'attente (TRY-with-timeout)

Java fournit un mécanisme de verrouillage plus flexible comme ReentrantLock , qui prend en charge l'essai d'acquérir des verrous et de définir des délais d'attente. Cette méthode peut abandonner activement lorsque le verrou n'est pas acquis, plut?t que d'attendre indéfiniment.

Pratiques suggérées:

• Utilisez la méthode tryLock() au lieu de synchronized
• Réglez le temps d'attente raisonnable pour éviter un blocage permanent

Exemple de code:

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

booléen acquise1 = lock1.trylock ();
booléen acquise2 = false;

if (acquis1) {
    essayer {
        acquis2 = lock2.trylock (500, timeunit.millisecondes);
    } enfin {
        if (! acquise2) lock1.unlock ();
    }
}

Si le deuxième serrure ne peut pas être acquis dans le délai spécifié, vous pouvez libérer la ressource acquise et réessayer ou sortir pour éviter de tomber dans un état de blocage.

3. Réduire la portée de la verrouillage

Plusieurs fois, pour la simplicité et la commodité, nous verrouillerons directement toute la méthode ou utiliserons une large gamme de blocs de synchronisation, ce qui affecte non seulement les performances, mais augmente également le risque de blocage.

Direction d'optimisation:

• Déplacer le code qui n'a pas besoin d'être synchronisé hors du bloc de synchronisation
• Essayez d'utiliser des variables locales au lieu de ressources partagées
• Utilisez des classes de collecte simultanées (telles que ConcurrentHashMap ) au lieu du verrouillage manuel

Par exemple:

 // non recommandée de pratique synchronisée vide badmethod () {
    // fait beaucoup d'opérations qui n'impliquent pas SharedResource.dosomething ();
}

// meilleure méthode d'écriture void BetterMethod () {
    // Verrouillez uniquement les pièces de clé synchronisées (SharedResource) {
        SharedResource.doSomething ();
    }
}

Plus la plage de verrouillage est petite, plus il est court du temps où il tient la serrure, plus la probabilité de conflit est faible.

4. Utilisez des outils pour détecter

Même si vous avez soigneusement affaire à la logique multi-thread, il peut y avoir des omissions. Pour le moment, vous pouvez utiliser des outils pour aider à vérifier les risques potentiels de blocage:

• JVM est livré avec l'outil JSTACK : il peut imprimer des piles de threads pour identifier les threads en attente et quel verrouillage ils attendent.
• VisualVM ou JConsole : outil graphique qui peut surveiller l'état du thread en temps réel et même inviter automatiquement à des blocs de blocage possibles.
• Outil de plug-in ou d'analyse statique IDE : tels que la fonction d'analyse de thread d'Intellij, peut également donner des invites pendant l'étape de codage.

Exécuter l'exemple de commande:

 JSTACK <PID> | grep -i impasse

Cette commande peut vous aider à localiser rapidement s'il y a une impasse.

Fondamentalement, c'est tout. Bien que les impasses puissent sembler un peu compliquées, tant que vous faites attention à l'ordre de verrouillage, réduisez la plage de verrouillage, utilisez des verrous explicites raisonnablement et combinez avec le dépannage des outils, il peut réduire considérablement sa probabilité de survenue.

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!