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

Existe-t-il un moyen d'obtenir une liste de tous les threads en cours d'exécution dans la JVM actuelle (y compris les threads non démarrés par ma classe)?

Est-il également possible d'obtenir les objets Threadet Classde tous les threads de la liste?

Je veux pouvoir le faire via du code.

Pour obtenir un ensemble itérable:

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

Obtenez une poignée à la racine ThreadGroup, comme ceci:

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

Maintenant, appelez la enumerate()fonction 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 () jusqu'à ce que le tableau soit suffisamment grand pour contenir toutes les entrées.

Oui, jetez un œil à l' 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 VM fera un vidage des threads vers stdout.

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

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

Avez-vous jeté un œil à jconsole ?

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

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

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

Les utilisateurs d'Apache Commons peuvent utiliser ThreadUtils. L'implémentation actuelle utilise l'approche Walk the Thread Group décrite précédemment.

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

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 fil si vous en avez besoin.

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

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

En Java , vous pouvez invoquer cette méthode en utilisant la réflexion à condition que le gestionnaire de sécurité le permette.

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

production:

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

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

Dans la console java, appuyez sur Ctrl-Break . Il répertorie tous les threads ainsi que quelques 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.

Pour obtenir une liste des threads et leurs états complets à l'aide du terminal, vous pouvez utiliser la commande ci-dessous:

jstack -l <PID>

Quel PID est l'ID du processus en cours d'exécution sur votre ordinateur. Pour obtenir l'ID de processus de votre processus java, vous pouvez simplement exécuter la jpscommande.

En outre, vous pouvez analyser votre vidage de threads produit par jstack dans TDAs (Thread Dump Analyzer) tel un outil d'analyse de threads rapide ou spotify .

ManagementFactory.getThreadMXBean().getAllThreadIds()