La détection de blocage en Java

Il y a longtemps, j'ai sauvé une phrase à partir d'un Java livre de référence: "Java n'a pas de mécanisme de poignée de blocage. il ne sait même pas de blocage s'est produit." (La tête la Première, Java 2nd Edition, p.516)

L'affirmative, quelle est-elle? Est-il un moyen de rattraper impasse cas en Java? Je veux dire, est-il possible que notre code comprend une impasse cas s'est produit?

  • Est Java différent dans d'autres langues à cet égard?
  • il n'est pas impossible de détecter un blocage - c'est juste assez difficile
  • par exemple la plupart des bases de données permettra de détecter les blocages
  • Java peut ne pas disposer d'un mécanisme à "gérer" les blocages, mais il le FAIT savoir sur les blocages. Lire mon post ci-dessous et je vais expliquer comment...
  • N'est-ce pas à cette question, un doublon de: stackoverflow.com/questions/1102359
InformationsquelleAutor israkir | 2008-10-19
  1. 79

    Depuis le JDK 1.5 il y a des méthodes utiles dans le java.lang.management paquet de trouver et d'inspecter les blocages qui se produit. Voir la findMonitorDeadlockedThreads() et findDeadlockedThreads() méthode de la ThreadMXBean classe.

    Une façon possible de l'utiliser c'est d'avoir un chien de garde thread (ou tâche périodique) qui fait cela.

    Exemple de code:

      ThreadMXBean tmx = ManagementFactory.getThreadMXBean();
  long[] ids = tmx.findDeadlockedThreads();
  if (ids != null) {
     ThreadInfo[] infos = tmx.getThreadInfo(ids, true, true);
     System.out.println("The following threads are deadlocked:");
     for (ThreadInfo ti : infos) {
        System.out.println(ti);
     }
  }
    • C'est génial que java a cela..! Je pense que j'étais proche de la rupture vers le bas et commencer à pleurer
    InformationsquelleAutor staffan
  2. 18

    JConsole est capable de détecter les blocages dans une application en cours d'exécution.

    InformationsquelleAutor Steve K
  3. 11

    JDK 5 et 6 de vidage de la tenue de verrouillage de l'information dans un thread dump (obtenu avec kill -3, jstack, jconsole, etc). JDK 6 contient des informations sur ReentrantLock et ReentrantReadWriteLock. Il est possible à partir de cette information pour diagnostiquer un blocage par trouver un verrouillage du cycle: le Fil d'Un titulaire de verrouillage 1, le Fil B est titulaire de la serrure 2, et soit d'Une demande de 2 ou B demande 1. De mon expérience, ce n'est généralement assez évident.

    D'autres outils d'analyse peut effectivement trouver les blocages potentiels, même si elles ne se produisent pas. Outils de la discussion des vendeurs tels que OptimizeIt, JProbe, Coverity, etc sont de bons endroits pour chercher.

    InformationsquelleAutor Alex Miller
  4. 8

    Remarque qu'il y a un type de blocage à l'aide de la simultanées paquet qui est très difficile à déboguer. C'est là que vous avez un ReentrantReadWriteLock et un thread attrape le verrou en lecture et ensuite (dire) essaie d'entrer dans un moniteur détenus par un autre thread qui est également en attente pour saisir le verrou d'écriture. Ce qui le rend particulièrement difficile à déboguer est qu'il n'y a aucune trace de qui est entré dans un verrou en lecture. C'est tout simplement un chef d'accusation. Le thread peut même avoir jeté une exception et est décédé en laissant le lire le nombre non nul.

    Voici un exemple d'une impasse que l'findDeadlockedThreads méthode mentionné plus tôt, de ne pas obtenir de:

    import java.util.concurrent.locks.*;
import java.lang.management.*;
public class LockTest {
static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public static void main(String[] args) throws Exception {
Reader reader = new Reader();
Writer writer = new Writer();
sleep(10);
System.out.println("finding deadlocked threads");
ThreadMXBean tmx = ManagementFactory.getThreadMXBean();
long[] ids = tmx.findDeadlockedThreads();
if (ids != null) {
ThreadInfo[] infos = tmx.getThreadInfo(ids, true, true);
System.out.println("the following threads are deadlocked:");
for (ThreadInfo ti : infos) {
System.out.println(ti);
}
}
System.out.println("finished finding deadlocked threads");
}
static void sleep(int seconds) {
try {
Thread.currentThread().sleep(seconds*1000);
} catch (InterruptedException e) {}
}
static class Reader implements Runnable {
Reader() {
new Thread(this).start();
}
public void run() {
sleep(2);
System.out.println("reader thread getting lock");
lock.readLock().lock();
System.out.println("reader thread got lock");
synchronized (lock) {
System.out.println("reader thread inside monitor!");
lock.readLock().unlock();
}
}
}
static class Writer implements Runnable {
Writer() {
new Thread(this).start();
}
public void run() {
synchronized (lock) {
sleep(4);
System.out.println("writer thread getting lock");
lock.writeLock().lock();
System.out.println("writer thread got lock!");
}
}
}
}
    • Vraiment excellent exemple... en dehors de la recherche pour les threads en ATTENTE/état BLOQUÉ via jstack, il n'existe pas d'autres indications que nous pourrions envisager, dans une telle situation?
    InformationsquelleAutor Dave Griffiths
  5. 6

    En général java ne propose pas de détection de blocage. Le mot-clé synchronized et construit dans les moniteurs de le rendre un peu plus difficile à propos de l'impasse que dans les langues explicite de verrouillage.

    Je suggère de migration à l'aide de java.util.de façon concomitante.Verrouille et afin de faire votre installation de fermeture régimes plus facile de raisonner sur. En fait, vous pouvez facilement faire votre propre implémentation de l'interface de verrouillage avec détection de blocage. L'algorithme consiste pour l'essentiel à traverser la serrure graphe de dépendance et de regarder pour un cycle.

    • Les serrures en java.util.de façon concomitante.Serrure de blocage de détection construit en tant que de JDK 1.6. Voir java.lang.de la gestion.ThreadMXBean.
    InformationsquelleAutor luke
  6. 4

    Si vous êtes sur Java 5, vous pouvez appeler la méthode findMonitorDeadlockedThreads() sur le ThreadMXBean que vous pouvez obtenir grâce à un appel de java.lang.management.ManagementFactory.getThreadMXBean(). Cela permettra de trouver les blocages causés par des objets surveille uniquement. Sur la version 6 de Java il y a findDeadlockedThreads() qui sera également trouver des blocages causés par des "ownable synchroniseurs (par exemple ReentrandLock et ReentrantReadWriteLock).

    Être conscient qu'il sera probablement coûteux d'appeler ces méthodes, elles doivent donc être utilisées pour des fins de dépannage.

    InformationsquelleAutor WMR
  7. 4

    Des blocages peuvent être évités si vous suivez une règle simple: avoir tous les threads de réclamation et quittance leurs verrous dans le même ordre. De cette façon, vous ne jamais être dans une situation où un blocage peut se produire.

    Même à manger des philosophes problème peut être vu comme une violation de cette règle, car il utilise une relative concepts de droite et de gauche cuillère qui résultat dans différents threads à l'aide de différents répartition des ordonnances de la cuiller. Si les cuillères ont été numérotés de façon unique et les philosophes ont tous essayé d'obtenir le plus petit numéro de cuillère d'abord, blocage serait impossible.

    À mon avis, mieux vaut prévenir que guérir.

    C'est l'une des deux lignes directrices j'aime à suivre pour garantir que les threads de travail correctement. L'autre est de s'assurer que chaque thread est uniquement responsable de sa propre exécution, comme c'est le seul que pleinement conscient de ce qu'il fait à n'importe quel point dans le temps.

    Ce qui signifie que pas de Thread.stop des appels, utiliser un indicateur global (ou file d'attente de message ou quelque chose comme ça) de dire à un autre thread que vous voulez de l'action prise. Alors laissez ce thread faire le travail réel.

    • Alors que c'est la réponse canonique, il n'est pas toujours possible. Il existe d'autres moyens pour éviter un blocage ainsi. Par exemple, vous pouvez utiliser chronométré tryLocks (avec un ReentrantLock) de faire marche arrière.
    • Se verrouille dans le même ordre n'est simple, si les verrous sont tous dans la même fonction. Si les différentes fonctions de saisir les verrous et peuvent s'appeler les uns les autres dans différents modèles, ce qui est une situation commune, de garantir l'ordre devient de plus en plus difficile. J'ai souvent trouvé la stratégie de la réduction de la durée de verrous, et à l'aide d'un seul verrou global, peut mieux travailler. D'accord avec le reste de la réponse sur le thread de la responsabilité et de la communication.
    • si vous écrivez du code, vous pouvez contrôler le verrouillage de l'ordre, peu importe si c'est fait à partir d'une seule fonction. Par exemple, dans le passé j'ai mis en œuvre mutex porte-clés (un groupe de mutex dans un ordre précis) lorsque vous verrouillez l'ensemble du trousseau de clés pour exactement cet effet, garantissant pas de blocages. La minimisation du délai de verrouillage est une bonne idée, peu importe la stratégie que vous utilisez pour le blocage d'évitement mais le problème mondial de la serrure de son champ d'application. Souvent, il va ralentir les choses par le verrouillage de trop à la fois - c'est un compromis intéressant d'examiner, mais il est un compromis avec un coût.
    • chronométré serrures avec backouts sont une stratégie pour éviter les blocages, mais, malheureusement, signifie que vous n'avez pas toujours le verrou, vous devez (et peut entraîner une absence de cycle non productif qui est souvent tout aussi mauvais). Si vous avez besoin d'obtenir le verrou sur un groupe de ressources, ordonné le blocage des composants individuels garantit à la fois ni blocage, ni l'absence de cycle non productif, conduisant à une plus juste répartition.
    InformationsquelleAutor paxdiablo
  8. 3

    Pas exactement ce que vous avez demandé, mais lorsqu'un blocage ne se produire, vous pouvez faire un "kill -3" sur l'id de processus et elle exporte un thread dump sur la sortie standard stdout. Aussi, la jvm 1.6 a quelques outils pour faire la même chose dans une interface graphique manière.

    InformationsquelleAutor Paul Tomblin
  9. 3

    Si vous exécutez à partir de la ligne de commande et vous pensez que vous êtes dans l'impasse, essayez d'appuyer sur ctrl+pause dans windows (ctrl+\ sous unix) pour obtenir un thread dump.
    Voir http://java.sun.com/javase/6/webnotes/trouble/TSG-VM/html/gbmps.html

    InformationsquelleAutor Paul Croarkin
  10. 3

    Le dr Heinz Kabutz de JavaSpecialists a écrit un divertissant et instructif bulletin d'information sur Java blocages et décrit quelque chose qui s'appelle un ThreadMXBean dans un autre numéro de ce bulletin. Entre ceux-ci, vous devriez avoir une bonne idée des problèmes et quelques conseils pour faire votre propre instrumentation.

    InformationsquelleAutor user29480
  11. 3

    Java peut détecter les blocages (mais pas au moment de l'exécution, il peut diagnostiquer et de le signaler).

    Par exemple, lors de l'utilisation d'une version légèrement modifiée de " Saurabh M. Chande code soufflet (changé en Java et ajouté un peu de timing pour garantir un verrou sur chaque course). Une fois que vous l'exécutez, et il les blocages, si vous tapez:

    kill -3 PID   # where 'PID' is the Linux process ID

    Il va générer un dump de la pile, qui comprendra les informations suivantes:

    Found one Java-level deadlock:
=============================
"Thread-0":
waiting to lock monitor 0x08081670 (object 0x7f61ddb8, a Deadlock$A),
which is held by "main"
"main":
waiting to lock monitor 0x080809f0 (object 0x7f61f3b0, a Deadlock$B),
which is held by "Thread-0"
    InformationsquelleAutor Jeach
  12. 2

    Si vous êtes le débogage dans eclipse, vous pouvez mettre en pause l'application (sélectionnez l'application dans la vue débogage et le peu de || sur le bouton de barre d'outils de débogage) et puis il peut signaler les blocages.

    Voir http://runnerwhocodes.blogspot.com/2007/10/deadlock-detection-with-eclipse.html pour un exemple.

    InformationsquelleAutor Scott Stanchfield
  13. 0

    Java 5 introduit ThreadMXBean - une interface qui offre diverses méthodes de surveillance pour les threads. ... La différence est que findDeadlockedThreads peut également détecter les blocages causés par le propriétaire de serrures (java.util.en même temps), alors que findMonitorDeadlockedThreads ne peut détecter le moniteur de serrures (c'est à dire synchronisé blocs)

    Ou vous pouvez le détecter par programmation, reportez-vous à cette https://dzone.com/articles/how-detect-java-deadlocks

    InformationsquelleAutor Amol Fasale
  14. -1

    Après si longtemps, je suis en mesure d'écrire l'exemple le plus simple de Blocage.
    Les commentaires sont les bienvenus. 

    Class A
{
synchronized void methodA(B b)
{
b.last();
}
synchronized void last()
{
SOP(“ Inside A.last()”);
}
}
Class B
{
synchronized void methodB(A a)
{
a.last();
}
synchronized void last()
{
SOP(“ Inside B.last()”);
}
}
Class Deadlock implements Runnable 
{
A a = new A(); 
B b = new B();
//Constructor
Deadlock()
{
Thread t = new Thread(); 
t.start();
a.methodA(b);
}
public void run()
{
b.methodB(a);
}
public static void main(String args[] )
{
new Deadlock();
}
}
    • pas censé copier le code à partir d'un livre
    • Ce livre? Si c'est le plagiat, je vais le marquer.
    InformationsquelleAutor Saurabh M. Chande
  15. -4

    vous devez modifier un peu le code dans le Blocage de la Classe 

     De blocage() { 
Therad t = new Thread(this); //modification de la 
t.start(); 
Système.out.println(); //une instruction de retard 
un.methodA(b); 
}

    Également le code ci-dessus ne sera pas toujours la cause d'une mort serrure, seulement quelques fois, il peut arriver.

    • Des retards est une lame de méthode pour éviter les blocages pour ultra paresseux développeurs qui ne veulent pas savoir attendre informer un peu. Nous sommes tourmentés par ce code écrit partout.
    InformationsquelleAutor venu