détection de blocage de programmation en java

Question

Comment puis-je programme détectons que l'impasse est survenue dans un programme Java?

Answer 1

Vous pouvez le faire en utilisant le programme ThreadMXBean livré avec le JDK:

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] threadIds = bean.findDeadlockedThreads(); // Returns null if no threads are deadlocked.

if (threadIds != null) {
    ThreadInfo[] infos = bean.getThreadInfo(threadIds);

    for (ThreadInfo info : infos) {
        StackTraceElement[] stack = info.getStackTrace();
        // Log or store stack trace information.
    }
}

Il est évident que vous devriez essayer d'isoler selon fil effectue cette vérification de blocage - Sinon, si ce thread DEADLOCKS il ne sera pas en mesure d'exécuter le contrôle

Par ailleurs c'est ce que JConsole est en utilisant sous les couvertures.

Answer 2

Un indice utile pour la recherche:

Si vous pouvez attraper l'application et le suspect en flagrant délit dans une impasse est survenue, allez et appuyez sur « Ctrl-Pause » dans la fenêtre de la console java.exe (ou « Ctrl- \ » sur Solaris / Linux). Le jvm videra l'état actuel et trace de la pile de tous les threads, trouver des serrures mortes et les décrire avec précision.

Il ressemblera à quelque chose comme ceci:

Full thread dump Java HotSpot(TM) Client VM (1.5.0_09-b03 mixed mode):

"[Test Timer] Request Queue" prio=6 tid=0x13d708d0 nid=0x1ec in Object.
    wait() [0x1b00f000..0x1b00fb68]
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at library.util.AsyncQueue.run(AsyncQueue.java:138)
        - locked <0x02e70000> (a test.server.scheduler.SchedulerRequestQueue)

    ...

Found one Java-level deadlock:
=============================
"Corba service":
  waiting to lock monitor 0x13c06684 (object 0x04697d90, a java.lang.Object),
  which is held by "[Server Connection] Heartbeat Timer"
"[Server Connection] Heartbeat Timer":
  waiting to lock monitor 0x13c065c4 (object 0x0467e728, a test.proxy.ServerProxy), which is held by "Corba service"

Java stack information for the threads listed above:
===================================================
"Corba service":
    at test.proxy.ServerProxy.stopHBWatchDog(ServerProxy:695)
    - waiting to lock <0x04697d90> (a java.lang.Object)
    ...

Answer 3

Vous pouvez détecter les threads par programmation ThreadMXBean dans l'impasse class.Here est le code,

    ThreadMXBean bean = ManagementFactory.getThreadMXBean();

    long ids[] = bean.findMonitorDeadlockedThreads();

    if(ids != null)
    {
        ThreadInfo threadInfo[] = bean.getThreadInfo(ids);

        for (ThreadInfo threadInfo1 : threadInfo)
        {
            System.out.println(threadInfo1.getThreadId());    //Prints the ID of deadlocked thread

            System.out.println(threadInfo1.getThreadName());  //Prints the name of deadlocked thread

            System.out.println(threadInfo1.getLockName());    //Prints the string representation of an object for which thread has entered into deadlock.

            System.out.println(threadInfo1.getLockOwnerId());  //Prints the ID of thread which currently owns the object lock

            System.out.println(threadInfo1.getLockOwnerName());  //Prints name of the thread which currently owns the object lock.
        }
    }
    else
    {
        System.out.println("No Deadlocked Threads");
    }

Cliquez ici pour plus d'informations sur la façon de détecter les fils de l'impasse.

Answer 4

Jarmus est une bibliothèque pour la détection et l'évitement blocage. Il inclut le support pour: Thread.join, CyclicBarrier, CountDownLatch, Phaser et ReentrantLock.

Pour utiliser Jarmus vous avez besoin d'instrumenter votre code. Que ce soit par une de ses classes instrumentés ou automatiquement avec le Jarmus instrumentar jarmusc.

java -jar jarmusc.jar yourprogram.jar checkedprogram.jar

Le yourprogram.jar d'entrée est le programme que vous voulez vérifier. La sortie est le même programme avec des contrôles pour trouver automatiquement une impasse.

Les obstacles ont besoin d'aide

Vérification Blocages avec les classes CyclicBarrier, CountDownLatch, Phaser est un peu délicat --- par exemple, JConsole ne peut pas détecter ces types de blocages. Jarmus a besoin d'un peu d'aide de vous: vous devez spécifier les threads de synchronisation influencent, nous les appelons enregistrés threads.

Dès que possible, le fil doit se marque enregistrée. Un bon endroit pour marquer les discussions enregistrées est à la méthode de début Runnable.run. JArmus.register(latch);

Exemple

Le programme suivant est correctement que DEADLOCKS identifié par Jarmus:

final CountDownLatch latch = new CountDownLatch(2);
final CyclicBarrier barrier = new CyclicBarrier(2);
final Queue<Exception> exceptions = new ArrayDeque<>();
Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            JArmus.register(barrier); // do not forget to register!
            JArmus.register(latch); // do not forget to register!
            latch.countDown();
            latch.await();
            barrier.await();
        } catch (Exception e) {
            exceptions.add(e);
        }
    }
});
Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            JArmus.register(barrier); // do not forget to register!
            JArmus.register(latch); // do not forget to register!
            barrier.await();
            latch.countDown();
            latch.await();
        } catch (Exception e) {
            exceptions.add(e);
        }
    }
});
t1.start();
t2.start();

Answer 5

Vous pouvez envisager IBM de MTRAT. Mieux vaut prévenir que guérir après tout. Multicore kit de développement logiciel est également livré avec un outil de détection de blocage.

Answer 6

Si vous ne souhaitez pas la détection de programmation, vous pouvez le faire via JConsole ; sur l'onglet fil il y a un bouton « détecter impasse ». Dans ce JDK6 détecter les verrous pour les moniteurs intrinsèques et j.u.cs de Lock

Exécuter la JConsole via la commande $JAVA_HOM/bin/jconsole

Answer 7

Il est ici code: http://www.java2s.com /Code/Java/Development-Class/PerformingdeadlockdetectionprogrammaticallywithintheapplicationusingthejavalangmanagementAPI.htm

La magie se passe dans ThreadMonitor.findDeadlock():

  public boolean findDeadlock() {
    long[] tids;
    if (findDeadlocksMethodName.equals("findDeadlockedThreads")
        && tmbean.isSynchronizerUsageSupported()) {
      tids = tmbean.findDeadlockedThreads();
      if (tids == null) {
        return false;
      }

      System.out.println("Deadlock found :-");
      ThreadInfo[] infos = tmbean.getThreadInfo(tids, true, true);
      for (ThreadInfo ti : infos) {
        printThreadInfo(ti);
        printLockInfo(ti.getLockedSynchronizers());
        System.out.println();
      }
    } else {
      tids = tmbean.findMonitorDeadlockedThreads();
      if (tids == null) {
        return false;
      }
      ThreadInfo[] infos = tmbean.getThreadInfo(tids, Integer.MAX_VALUE);
      for (ThreadInfo ti : infos) {
        // print thread information
        printThreadInfo(ti);
      }
    }

    return true;
  }

appelle une API du ThreadMXBean qui a un nom différent en Java 5 et 6 (d'où le if() externe).

L'exemple de code permet également d'interrompre les serrures, de sorte que vous pouvez même sortir de l'impasse.

Answer 8

tempus-fugit met également en œuvre le long d'un fil programmatique classe de dumping. Il est mis en œuvre en utilisant le mécanisme mbean mentionné ci-dessus et offre une baisse, hors-the-box super solution Duper.

Answer 9

Si vous voulez que cela se fasse dans l'exécution, vous pouvez utiliser chien de garde que.