Obtenez une liste de tous les Threads en cours d'exécution en Java

Obtenez un handle à la racine ThreadGroup, comme ceci:

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

Maintenant, appelez la fonction enumerate() sur le groupe racine à plusieurs reprises. Le deuxième argument vous permet d'obtenir tous les threads, récursivement:

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

Notez comment nous appelons enumerate() à plusieurs reprises jusqu'à ce que le tableau soit assez grand pour contenir toutes les entrées.

Oui, jetez un oeil à obtention d'une liste de threads. Beaucoup d'exemples sur cette page.

C'est pour le faire par programme. Si vous voulez juste une liste sur Linux, au moins, vous pouvez simplement utiliser cette commande:

kill -3 processid

Et la machine virtuelle fera un vidage de thread vers stdout.

Vous pouvez obtenir beaucoup d'informations sur les threads à partir du ThreadMXBean.

Appelez le ManagementFactory statique.getThreadMXBean () méthode pour obtenir une référence au MBean.

Avez-vous regardé jconsole?

Cela listera tous les threads en cours d'exécution pour un processus Java particulier.

Vous pouvez démarrer jconsole à partir du dossier JDK bin.

Vous pouvez également obtenir une trace de pile complète pour tous les threads en appuyant sur Ctrl+Break sous Windows ou en envoyant kill pid --QUIT sous Linux.

Dans Groovy, vous pouvez appeler les méthodes privées

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

Dans Java, vous pouvez invoquer cette méthode en utilisant la réflexion à condition que security manager le permette.

Dans la console java, appuyez sur Ctrl-Break. Il répertoriera tous les threads ainsi que certaines informations sur le tas. Cela ne vous donnera pas accès aux objets bien sûr. Mais cela peut être très utile pour le débogage de toute façon.

, Vous pouvez essayer quelque chose comme ceci:

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

Et vous pouvez évidemment obtenir plus de caractéristiques de thread si vous en avez besoin.

    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 + "  ");
        }
    }

Extrait de code pour obtenir la liste des threads démarrés par le thread principal:

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();
        }
    }
}

Sortie:

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

Si vous avez besoin de tous les threads, y compris les threads système, qui n'ont pas été démarrés par votre programme, supprimez la condition ci-dessous.

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

Maintenant sortie:

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

Les utilisateurs d'Apache commons peuvent utiliser ThreadUtils. L'implémentation actuelle utilise l'approche walk the thread group précédemment décrite.

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

ManagementFactory.getThreadMXBean().getAllThreadIds()