Obtenha uma lista de todos os threads atualmente em execução em Java

Existe alguma maneira de obter uma lista de todos os threads em execução na JVM atual (incluindo os threads não iniciados pela minha classe)?

Também é possível obter os objetos Threade Classde todos os threads na lista?

Eu quero ser capaz de fazer isso através do código.

Para obter um conjunto iterável:

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

Obtenha um identificador para a raiz ThreadGroup, assim:

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

Agora, chame a enumerate()função no grupo raiz repetidamente. O segundo argumento permite obter todos os threads, recursivamente:

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

Observe como chamamos enumerate () repetidamente até que a matriz seja grande o suficiente para conter todas as entradas.

Sim, veja como obter uma lista de threads . Muitos exemplos nessa página.

Isso é feito programaticamente. Se você deseja apenas uma lista no Linux, pelo menos, basta usar este comando:

kill -3 processid

e a VM fará um despejo de encadeamento para stdout.

Você pode obter muitas informações sobre threads no ThreadMXBean .

Chame o método estático ManagementFactory.getThreadMXBean () para obter uma referência ao MBean.

Você já deu uma olhada no jconsole ?

Isso listará todos os threads em execução para um processo Java específico.

Você pode iniciar o jconsole a partir da pasta bin do JDK.

Você também pode obter um rastreamento de pilha completo para todos os threads pressionando Ctrl+Breakno Windows ou enviando kill pid --QUITno Linux.

Os usuários do Apache Commons podem usar ThreadUtils. A implementação atual usa a abordagem do grupo de threads, descrita anteriormente.

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

Você pode tentar algo como isto:

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

e, obviamente, você pode obter mais características de threads, se precisar.

No Groovy, você pode chamar métodos privados

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

Em Java , você pode chamar esse método usando reflexão, desde que o gerenciador de segurança permita.

Snippet de código para obter a lista de threads iniciada pelo 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();
        }
    }
}

resultado:

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

Se você precisar de todos os threads, incluindo os do sistema, que não foram iniciados pelo seu programa, remova a condição abaixo.

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

Agora saída:

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

No console java, pressione Ctrl-Break . Ele listará todos os threads, além de algumas informações sobre o heap. Isso não permitirá o acesso aos objetos, é claro. Mas pode ser muito útil para depuração de qualquer maneira.

Para obter uma lista de threads e seus estados completos usando o terminal, você pode usar o comando abaixo:

jstack -l <PID>

Qual PID é o ID do processo em execução no seu computador. Para obter o ID do processo java, você pode simplesmente executar o jpscomando

Além disso, você pode analisar seu dump de encadeamento produzido pelo jstack nos TDAs (Thread Dump Analyzer), como a ferramenta fastthread ou o analisador de encadeamento spotify .

ManagementFactory.getThreadMXBean().getAllThreadIds()