Comment détecter l'impasse ? Délai d'attente en synchronisation de bloc?

Je suis le débogage d'une application Java qui s'exécute en plusieurs threads. Après un certain temps de regarder le journal, il semble que l'un de ces fils n'est pas en cours d'exécution plus. Ma conjecture est que le thread est en attente d'un verrou qui n'est jamais sorti (la dernière sortie avant l'appel d'une méthode synchronisée).

Puis-je configurer un délai d'attente pour le thread; une sorte de “attendre pour cette serrure, mais si elle n'est pas disponible après 10 secondes n'attendez plus!”

Ressemble à une copie de stackoverflow.com/questions/1192151/...
OK, peut-être pas un doublon, mais il y a beaucoup de chevauchement.
Vous pouvez détecter les blocages en Java par programmation à l'aide ThreadMXBean classe. Découvrez korhner.github.io/java/multithreading/...

OriginalL'auteur Dani Cricco | 2009-07-28

24

Vous pouvez utiliser un java.util.de façon concomitante.Verrouillage au lieu de la valeur intrinsèque Object serrures. RentrantLock sans fair de la commande a le même comportement et la sémantique intrinsèque de verrouillage. Il existe une méthode tryLock qui prend un paramètre de délai d'expiration:
```
Lock lock = ...;
if (lock.tryLock(10L, TimeUnit.SECONDS)) {
    try {
        //manipulate protected state
    } finally {
        lock.unlock();
    }
} else {
      //perform alternative actions
}
```
OriginalL'auteur Ben Lings
10

Plutôt que d'ajouter du code supplémentaire pour le débogage, vous pouvez utiliser un outil de débogage ou d'un profileur.

Une option est d'utiliser quelque chose comme JConsole (livré avec le JDK), qui comprend un bouton "Détecter l'Impasse" (au moins, il n'en Java 6, je ne pense pas que cela fonctionne en Java 5). Une autre option est de créer un thread dump de la console - sur Unix, vous pouvez taper "tuer -3" alors que sur Windows CTRL+BRK fonctionne. D'autres outils de profilage tels que VisualVM (également dans le JDK) peut vous aider. Enfin, il y a JCarder qui est "un outil open source pour trouver les blocages potentiels en simultané multi-thread Java programmes".

+1 pour la jconsole et de détecter les blocages.

OriginalL'auteur Rich

Vous pouvez avoir les threads partagent explicite de verrouillage (voir java.util.de façon concomitante.verrouillage.Lock). Vous pouvez ensuite utiliser le Verrou.tryLock(), qui peut prendre une option de délai d'attente.

Vous pouvez également utiliser le jstack utilitaire qui vient avec la version 1.6 de java (pas sûr de 1.5) qui permet d'imprimer l'état de l'ensemble de vos fils et de ce qu'ils peuvent ou peuvent ne pas être en attente pour les. Appelez simplement avec l'id de processus. par exemple. :

  > jstack PID 

        "Signal Dispatcher" daemon prio=10 tid=0x00000000408e8400 nid=0x79a8 runnable [0x0000000000000000..0x000000004143f810]
           java.lang.Thread.State: RUNNABLE

        "Finalizer" daemon prio=10 tid=0x00000000408c9400 nid=0x79a7 in Object.wait() [0x0000000041a7b000..0x0000000041a7bb00]
           java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00007f992d1e7050> (a java.lang.ref.ReferenceQueue$Lock)
            at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:116)
            - locked <0x00007f992d1e7050> (a java.lang.ref.ReferenceQueue$Lock)
            at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:132)
            at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)

        "Reference Handler" daemon prio=10 tid=0x00000000408c2000 nid=0x79a6 in Object.wait() [0x000000004197a000..0x000000004197ac80]
           java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00007f992d41a958> (a java.lang.ref.Reference$Lock)
            at java.lang.Object.wait(Object.java:485)
            at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
            - locked <0x00007f992d41a958> (a java.lang.ref.Reference$Lock)

OriginalL'auteur Steve B.

1

Vous ne pouvez pas utiliser délais d'attente toujours synchronisé méthodes. Cependant, l'utilisation de la "nouvelle" de java.util.simultanée d'autres choses, vous pouvez utiliser programatic les verrous de délai de soutien.

Regardez, par exemple, java.util.de façon concomitante.les verrous.ReentrantLock

Réentrante Verrou d'exclusion mutuelle avec
le même comportement de base et de la sémantique
comme l'implicite moniteur verrouiller accessible
à l'aide de méthodes synchronisées et
états, mais avec de longues
des capacités.

OriginalL'auteur skaffman
1

Il peut y avoir 2 raisons:
1) Le fil est mort
2) Le fil est verrouillé quelque part ou faire quelque chose que vous n'avez pas anticiper.

La meilleure solution est de toujours utiliser un débogueur (attendre que la situation se produit, puis pauze les applications) ou de l'utilisation JConsole/JStack/JVisualVM.

OriginalL'auteur David Nouls
0

Alors qu'il est possible d'avoir des délais d'attente lors de l'attente pour les serrures synchronisé méthodes de mise en œuvre de ces est difficile à manier. Fondamentalement, vous donnerait naissance à un thread horloge qui pourrait interrompre le bloc de fil après T secondes...pas sympa.

Si vous êtes à l'aide de Java 5 ou plus, je vous suggère fortement de voir ce que la nouvelle de la simultanéité des classes d'offre. Par exemple, vous pourriez envisager d'utiliser la ReentrantLock, qui possède une méthode tryLock(délai long, TimeUnit unit) qui vous permettra de tenter d'acquérir le verrou, mais permet de s'évader après une période de temps déterminée.

OriginalL'auteur Il-Bhima
0

Vous pouvez utiliser JMX (Java Management Extension) de l'API à la figure mortes de verrouillage en java. Découvrez http://ourownjava.com/how-to-identify-deadlock-in-java pour un exemple.

OriginalL'auteur Sanju Thomas

Vous devez vous connecter pour publier un commentaire.