Rufen Sie eine Liste aller Threads ab, die derzeit in Java ausgeführt werden

Gibt es eine Möglichkeit, eine Liste aller laufenden Threads in der aktuellen JVM (einschließlich der Threads) abzurufen? nicht von meiner Klasse gestartet wurden)?

Ist es auch möglich das zu bekommen Thread und ClassObjekte aller Threads in der Liste abzurufen?

Ich möchte dies durch Code tun können.

So erhalten Sie einen iterierbaren Satz:

Set<Thread> threadSet = Thread.getAllStackTraces().keySet();

Holen Sie sich einen Griff zur Wurzel ThreadGroup, wie folgt:

ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
ThreadGroup parentGroup;
while ((parentGroup = rootGroup.getParent()) != null) {
    rootGroup = parentGroup;
}

Rufen Sie nun die enumerate()Funktion für die Stammgruppe wiederholt auf. Mit dem zweiten Argument können Sie alle Threads rekursiv abrufen:

Thread[] threads = new Thread[rootGroup.activeCount()];
while (rootGroup.enumerate(threads, true ) == threads.length) {
    threads = new Thread[threads.length * 2];
}

Beachten Sie, wie wir enumerate () wiederholt aufrufen, bis das Array groß genug ist, um alle Einträge zu enthalten.

Ja, sehen Sie sich eine Liste der Themen an . Viele Beispiele auf dieser Seite.

Das ist programmgesteuert. Wenn Sie nur eine Liste unter Linux wünschen, können Sie einfach diesen Befehl verwenden:

kill -3 processid

und die VM führt einen Thread-Dump für stdout durch.

In der ThreadMXBean können Sie viele Informationen zu Threads abrufen .

Rufen Sie die statische ManagementFactory.getThreadMXBean () -Methode auf, um einen Verweis auf die MBean abzurufen.

Haben Sie sich jconsole angesehen? ?

Dadurch werden alle Threads aufgelistet, die für einen bestimmten Java-Prozess ausgeführt werden.

Sie können jconsole über den Ordner JDK bin starten.

Sie können auch eine vollständige Stapelverfolgung für alle Threads erhalten, indem Sie Ctrl+Breakin Windows klicken oder kill pid --QUITLinux senden .

Apache Commons-Benutzer können verwenden ThreadUtils. Die aktuelle Implementierung verwendet den zuvor beschriebenen Ansatz "Walk the Thread Group".

for (Thread t : ThreadUtils.getAllThreads()) {
      System.out.println(t.getName() + ", " + t.isDaemon());
}

Sie können so etwas ausprobieren:

Thread.getAllStackTraces().keySet().forEach((t) -> System.out.println(t.getName() + "\nIs Daemon " + t.isDaemon() + "\nIs Alive " + t.isAlive()));

und Sie können natürlich mehr Fadencharakteristik erhalten, wenn Sie benötigen.

In Groovy können Sie private Methoden aufrufen

// Get a snapshot of the list of all threads 
Thread[] threads = Thread.getThreads()

In Java können Sie diese Methode mithilfe von Reflection aufrufen, sofern der Sicherheitsmanager dies zulässt.

Code-Snippet, um eine Liste der Threads zu erhalten, die vom Haupt-Thread gestartet wurden:

import java.util.Set;

public class ThreadSet {
    public static void main(String args[]) throws Exception{
        Thread.currentThread().setName("ThreadSet");
        for ( int i=0; i< 3; i++){
            Thread t = new Thread(new MyThread());
            t.setName("MyThread:"+i);
            t.start();
        }
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        for ( Thread t : threadSet){
            if ( t.getThreadGroup() == Thread.currentThread().getThreadGroup()){
                System.out.println("Thread :"+t+":"+"state:"+t.getState());
            }
        }
    }
}

class MyThread implements Runnable{
    public void run(){
        try{
            Thread.sleep(5000);
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

Ausgabe:

Thread :Thread[MyThread:2,5,main]:state:TIMED_WAITING
Thread :Thread[MyThread:0,5,main]:state:TIMED_WAITING
Thread :Thread[MyThread:1,5,main]:state:TIMED_WAITING
Thread :Thread[ThreadSet,5,main]:state:RUNNABLE

Wenn Sie alle Threads einschließlich Systemthreads benötigen, die nicht von Ihrem Programm gestartet wurden, entfernen Sie die folgende Bedingung.

if ( t.getThreadGroup() == Thread.currentThread().getThreadGroup())

Jetzt ausgeben:

Thread :Thread[MyThread:2,5,main]:state:TIMED_WAITING
Thread :Thread[Reference Handler,10,system]:state:WAITING
Thread :Thread[MyThread:1,5,main]:state:TIMED_WAITING
Thread :Thread[ThreadSet,5,main]:state:RUNNABLE
Thread :Thread[MyThread:0,5,main]:state:TIMED_WAITING
Thread :Thread[Finalizer,8,system]:state:WAITING
Thread :Thread[Signal Dispatcher,9,system]:state:RUNNABLE
Thread :Thread[Attach Listener,5,system]:state:RUNNABLE

    public static void main(String[] args) {


        // Walk up all the way to the root thread group
        ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
        ThreadGroup parent;
        while ((parent = rootGroup.getParent()) != null) {
            rootGroup = parent;
        }

        listThreads(rootGroup, "");
    }


    // List all threads and recursively list all subgroup
    public static void listThreads(ThreadGroup group, String indent) {
        System.out.println(indent + "Group[" + group.getName() + 
                ":" + group.getClass()+"]");
        int nt = group.activeCount();
        Thread[] threads = new Thread[nt*2 + 10]; //nt is not accurate
        nt = group.enumerate(threads, false);

        // List every thread in the group
        for (int i=0; i<nt; i++) {
            Thread t = threads[i];
            System.out.println(indent + "  Thread[" + t.getName() 
                    + ":" + t.getClass() + "]");
        }

        // Recursively list all subgroups
        int ng = group.activeGroupCount();
        ThreadGroup[] groups = new ThreadGroup[ng*2 + 10];
        ng = group.enumerate(groups, false);

        for (int i=0; i<ng; i++) {
            listThreads(groups[i], indent + "  ");
        }
    }

Drücken Sie in der Java-Konsole Strg-Pause . Es werden alle Threads sowie einige Informationen zum Heap aufgelistet. Dadurch erhalten Sie natürlich keinen Zugriff auf die Objekte. Aber es kann trotzdem sehr hilfreich beim Debuggen sein.

Mit dem folgenden Befehl können Sie eine Liste der Threads und ihrer vollständigen Status mithilfe des Terminals abrufen:

jstack -l <PID>

Welche PID ist die ID des Prozesses, der auf Ihrem Computer ausgeführt wird? Um die Prozess-ID Ihres Java-Prozesses abzurufen, können Sie einfach den jpsBefehl ausführen .

Sie können auch Ihren Thread-Dump analysieren, der von jstack in TDAs (Thread Dump Analyzer) wie einem Fastthread- oder Spotify-Thread-Analyzer-Tool erstellt wurde .

ManagementFactory.getThreadMXBean().getAllThreadIds()