Traccia dello stack

"Ciao! Oggi ti dirò cos'è una traccia dello stack. Ma prima devo dirti cos'è uno stack."

"Immagina una pila di documenti: direttive per un determinato dipendente. Puoi mettere una nuova attività in cima alla pila o puoi prendere un'attività dall'alto. Ciò significa che le attività non verranno eseguite nell'ordine in cui sono state ricevute . L'attività inserita più di recente nella pila sarà la prima ad essere eseguita. Strutturando gli elementi di una raccolta in questo modo si forma una pila . "

" Java ha una raccolta speciale per questo: Stack . È una raccolta che ha metodi per 'aggiungere un elemento' e 'prendere (ottenere) un elemento'. Come avrai intuito, l'elemento che è stato aggiunto per ultimo sarà il primo a essere preso."

"Sembra piuttosto semplice."

"Fantastico. Adesso ti spiego cos'è una traccia dello stack ."

"Immagina che in un programma Java il metodo A chiami metodo B , che chiami metodo C , che a sua volta chiami metodo D . Per uscire dal metodo B , dobbiamo prima uscire dal metodo C , e per farlo dobbiamo prima uscire dal metodo D . Questo comportamento assomiglia a una pila."

"Perché dici che gli somiglia?"

"Per arrivare a qualche compito nel mezzo della nostra pila di fogli, ad esempio, devi prima eseguire tutti i compiti che si trovano sopra di esso."

"C'è qualche somiglianza, ma non sono sicuro di aver capito tutto correttamente."

"Guarda. Una pila è un insieme di elementi. Come pezzi di carta in una pila. Per prendere il terzo pezzo di carta dall'alto, devi prima prendere il secondo, e per questo devi prendere il primo. Tu puoi sempre mettere e prendere pezzi di carta, ma devi sempre prendere prima la carta più in alto."

"Lo stesso vale per le chiamate di funzione. Il metodo A chiama il metodo B , che chiama il metodo C . Per uscire da A , devi prima uscire da B e, per farlo, devi uscire da C ."

"Aspetta. Se capisco cosa stai dicendo, l'intero concetto di una pila si riduce a 'prendi il pezzo di carta che è stato aggiunto per ultimo' e 'puoi uscire solo dal metodo che hai inserito più di recente'. È esatto? "

"Sì. La sequenza delle chiamate di funzione è nota come 'call stack' o semplicemente 'stack'. L'ultima funzione chiamata è la prima funzione a terminare. Analizziamo un esempio."

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. Capisco tutto sulle chiamate di funzione. Ma cos'è questo StackTraceElement?"

"La Java Machine tiene traccia di tutte le chiamate di funzione. Per questo, ha una raccolta speciale: lo stack. Quando una funzione ne chiama un'altra, la Java Machine inserisce un nuovo oggetto StackTraceElement nello stack. Quando una funzione termina, quell'elemento viene rimosso dallo stack. Ciò significa che lo stack memorizza sempre informazioni aggiornate sullo stato corrente dello 'stack di chiamate di funzione'. "

"Ogni oggetto StackTraceElement contiene informazioni sul metodo chiamato. In particolare, puoi ottenere il nome del metodo utilizzando il metodo getMethodName ."

"Puoi vedere come funziona nell'esempio sopra:

1) Otteniamo lo stack di chiamate.

2) Usiamo un ciclo for-each per attraversarlo. Spero che tu non abbia dimenticato di cosa si tratta.

3) Inviamo i nomi dei metodi a System.out ."

"Affascinante! E nemmeno troppo complicato. Grazie, Rishi!"