Como encontrar um fio Java no tempo de execução

A arte de encontrar tópicos em tempo de execução envolve duas classes Java, linha e ThreadGroup. Além disso, você deve se lembrar de citar seu segmento ao criá-la. Caso contrário, se você não nomear seu segmento, você está contando com o mecanismo de nomenclatura padrão para tópicos construídos em Java, e enquanto você pode ser capaz de adivinhar o que o nome do segmento deve ser, não há garantia de que será o mesmo nome em toda todas as plataformas de tempo de execução e versões de Java.

Coisas que você precisa

Java Runtime Environment versão 6 ou superior

Crie a estrutura para uma classe de aplicativo Java chamado "Encontrar." Basta fornecer um método vazio principal () como o ponto de partida.
classe pública Find {
void main (args String []) public static {
}
}
Criar um objeto Runnable e linha de modo que você tem algo de encontrar. Nome da rosca "Dorminhoco" fornecendo um segundo argumento para o construtor Thread, onde o primeiro argumento é a referência Runnable. Depois de criar o Thread, iniciá-lo chamando seu método start (). O código a seguir começa a definição () método main agora vazio:
```
corredor Runnable = new Runnable () {public void run () {
experimentar {
Thread.sleep (50000);
} Catch (InterruptedException e) {
// ignore
}
}
};
Tópico t = new Thread (corredor, "Dorminhoco");
t.start () -
```
Encontrar o fio com a ajuda de ThreadGroup. Todos os tópicos pertencem a uma ThreadGroup. Estes grupos sentar-se em uma árvore, onde todos os grupos têm um nó pai (e nós filhos), excepto para a raiz da árvore, que não tem nenhum pai. Supondo que o fio de encontrar não está na ThreadGroup do segmento atual, caminhar até o topo da árvore, olhando para o pai do grupo. Dessa forma, quando você vai para encontrar o "Dorminhoco" fio, você vai saber que você encontrou uma vez que os tópicos ativos será filhos do segmento pai Overlord.
```
Passe CurrentThread = Thread.currentThread ();ThreadGroup group = currentThread.getThreadGroup ();
while (group.getParent ()! = null) {
group = group.getParent ();


}
```
Use o método enumerate () do ThreadGroup para agrupar todas as crianças tópicos deste super pai. O método armazena os tópicos ativos em uma matriz.
```
int activeCount group.activeCount = ();activeThreads de Tópicos [] = new Thread [activeCount + 5];
int actualCount = group.enumerate (activeThreads) -
```

Use a matriz activeThreads para ajudar a encontrar o segmento que faltava - aqui, a um marcado "Dorminhoco." Uma vez encontrado, use o método dumpStack () para fornecer um stacktrace da rosca:

Passe encontrado = null;for (int i = 0- i lt; actualCount- i ++) {
E se ("Dorminhoco".Equals (activeThreads [i] .getName ())) {
encontrado = activeThreads [i];
pausa;
}
}
if (encontrado! = null) {
found.dumpStack ();
}

Como a linha de fechamento para o seu método main (), dizer ao sistema para sair da memória:
System.exit (0);
Compilar e executar o programa. Enquanto os números de linha no rastreamento de pilha poderia ser um pouco diferente com base em coisas como estilo parênteses, todos eles devem fornecer o mesmo resultado geral.
java.lang.Exception: Rastreamento de pilha
```
 em java.lang.Thread.dumpStack (Thread.java:1206)em Find.main (Find.java:31)
```

De esta maneira? Compartilhar em redes sociais: