Trace de pile

« Salut ! Aujourd'hui, je vais te dire ce qu'est une trace de pile. Mais d'abord, je dois te dire ce qu'est une pile. »

« Imagine une pile de papiers, disons des directives pour un certain employé. Tu peux mettre une nouvelle tâche sur le dessus de la pile, ou tu peux prendre une tâche au sommet de la pile. Cela signifie que les tâches ne seront pas exécutées dans l'ordre où elles ont été reçues. La tâche placée sur la pile le plus récemment sera la première à être exécutée. Structurer les éléments d'une collection de cette façon forme une pile. »

« Java a une collection spéciale pour cela : Stack. C'est une collection qui a des méthodes pour « ajouter un élément » et « prendre (obtenir) un élément ». Comme tu l'auras peut-être déjà deviné, l'élément qui a été ajouté en dernier sera le premier à être pris. »

« Ça me semble assez simple. »

« Parfait. Maintenant, je vais t'expliquer ce qu'est une trace de pile. »

« Imagine que dans un programme Java, la méthode A appelle la méthode B, qui appelle la méthode C, qui à son tour appelle la méthode D. Pour sortir de la méthode B, nous devons terminer la méthode C, ce qui implique de terminer la méthode D avant. Ce comportement ressemble à celui d'une pile. »

« En quoi ça lui ressemble ? »

« Pour arriver à une tâche au milieu de notre pile de papiers, par exemple, tu dois d'abord exécuter toutes les tâches se trouvant au-dessus. »

« Il y a une certaine similitude, mais je ne suis pas sûr d'avoir tout compris correctement. »

« Regarde. Une pile est un ensemble d'éléments. Comme des morceaux de papier dans une pile. Pour prendre la troisième feuille de papier à partir du haut, tu dois d'abord prendre la deuxième, et pour cela, tu dois commencer par prendre la première. Tu peux toujours mettre et prendre des morceaux de papier, mais tu dois toujours prendre le papier du haut en premier. »

« La même chose est vraie pour les appels de fonction. La méthode A appelle la méthode B, qui appelle la méthode C. Pour quitter A, tu dois d'abord quitter B, ce qui implique de quitter C avant. »

« Une seconde. Si je comprends bien ce que tu dis, tout le concept d'une pile se résume à 'prendre le morceau de papier qui a été ajouté en dernier' et 'tu ne peux quitter que la méthode qui a commencé en dernier'. C'est bien ça ? »

« Oui. La séquence d'appels de fonction est connue sous le nom 'pile d'appels' ou plus simplement la 'pile'. La dernière fonction appelée est la première à se terminer. Plongeons-nous dans un exemple. »

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. J'ai tout compris sur les appels de fonction. Mais c'est quoi, ce StackTraceElement ? »

« La machine Java garde la trace de tous les appels de fonction. Pour cela, elle a une collection spéciale : la pile. Quand une fonction en appelle une autre, la machine Java place un nouvel objet StackTraceElement sur la pile. Quand une fonction se termine, l'élément est retiré de la pile. Cela signifie que la pile stocke toujours des informations à jour sur l'état actuel de la 'pile d'appels de fonction'. »

« Chaque objet StackTraceElement contient des informations sur la méthode appelée. En particulier, tu peux obtenir le nom de la méthode avec la méthode getMethodName. »

« Tu peux voir comment cela fonctionne dans l'exemple ci-dessus :

1) Nous récupérons la pile d'appels.

2) Nous utilisons une boucle for-each pour la parcourir. J'espère que tu n'as pas oublié ce que c'était.

3) Nous envoyons les noms des méthodes à System.out. »

« Fascinant ! Et pas trop compliqué, en plus. Merci, Rishi ! »