Rastreamento de pilha

"Oi! Hoje eu vou te dizer o que é um stack trace. Mas primeiro eu preciso te dizer o que é uma pilha."

"Imagine uma pilha de papéis - diretrizes para um determinado funcionário. Você pode colocar uma nova tarefa no topo da pilha ou pode retirar uma tarefa do topo. Isso significa que as tarefas não serão executadas na ordem em que foram recebidas . A tarefa colocada na pilha mais recentemente será a primeira a ser executada. Estruturar os elementos de uma coleção dessa forma forma uma pilha . "

" Java tem uma coleção especial para isso – Stack . É uma coleção que possui métodos para 'adicionar um elemento' e 'pegar (pegar) um elemento'. Como você deve ter adivinhado, o elemento que foi adicionado por último será o primeiro a ser tomados."

"Parece bastante direto."

"Ótimo. Agora vou explicar o que é um rastreamento de pilha ."

"Imagine que em um programa Java o método A chamasse o método B , que chamava o método C , que por sua vez chamava o método D . Para sair do método B , devemos primeiro sair do método C , e para fazer isso - devemos primeiro sair do método D . Isso comportamento se assemelha a uma pilha."

"Por que você diz que se parece com ele?"

"Para chegar a alguma tarefa no meio da nossa pilha de papéis, por exemplo, primeiro você precisa executar todas as tarefas que estão em cima dela."

"Há alguma semelhança, mas não tenho certeza se entendi tudo corretamente."

"Olha. Uma pilha é um conjunto de elementos. Como pedaços de papel em uma pilha. Para tirar o terceiro pedaço de papel do topo, primeiro você precisa pegar o segundo e, para isso, você precisa pegar o primeiro. Você sempre pode colocar e tirar pedaços de papel, mas você sempre tem que pegar o papel de cima primeiro."

"O mesmo vale para chamadas de função. O método A chama o método B , que chama o método C . Para sair de A , você deve primeiro sair de B e, para fazer isso, precisa sair de C ."

"Espere. Se eu entendo o que você está dizendo, todo o conceito de uma pilha se resume a 'pegar o pedaço de papel que foi adicionado por último' e 'você só pode sair do método que inseriu mais recentemente'. Isso é preciso? "

"Sim. A sequência de chamadas de função é conhecida como 'pilha de chamadas' ou simplesmente 'pilha'. A última função chamada é a primeira a terminar. Vamos nos aprofundar em um exemplo."

public class ExceptionExample
{
  public static void main(String[] args)
  {
    method1();
  }

  public static void method1()
  {
    method2();
  }

  public static void method2()
  {
    method3();
  }

  public static void method3()
  {
     StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
    for (StackTraceElement element : stackTraceElements)
    {
       System.out.println(element.getMethodName());
    }
  }
}

getStackTrace
method3
method2
method1
main

"OK. Entendo tudo sobre chamadas de função. Mas o que é esse StackTraceElement?"

"A Java Machine acompanha todas as chamadas de função. Para isso, ela possui uma coleção especial – a pilha. Quando uma função chama outra, a Java Machine coloca um novo objeto StackTraceElement na pilha. Quando uma função termina, esse elemento é removido da pilha. Isso significa que a pilha sempre armazena informações atualizadas sobre o estado atual da 'pilha de chamadas de função'. "

"Cada objeto StackTraceElement contém informações sobre o método chamado. Em particular, você pode obter o nome do método usando o método getMethodName ."

"Você pode ver como isso funciona no exemplo acima:

1) Obtemos a pilha de chamadas.

2) Usamos um loop for-each para passar por ele. Espero que você não tenha esquecido o que é isso.

3) Nós enviamos os nomes dos métodos para System.out ."

"Fascinante! E não muito complicado também. Obrigado, Rishi!"