Respostas:
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.
rootGroup
, você deve usar new Thread[rootGroup.activeCount()+1]
. activeCount()
pode ser zero e, se for, você encontrará um loop infinito.
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+Break
no Windows ou enviando kill pid --QUIT
no 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());
}
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 + " ");
}
}
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 jps
comando
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 .