Stack trace

"Hi! Ngayon sasabihin ko sa iyo kung ano ang stack trace. Pero kailangan ko munang sabihin sa iyo kung ano ang stack."

"Isipin ang isang tumpok ng mga papel – mga direktiba para sa isang partikular na empleyado. Maaari kang maglagay ng bagong gawain sa ibabaw ng pile, o maaari kang kumuha ng gawain mula sa itaas. Nangangahulugan ito na ang mga gawain ay hindi isasagawa sa pagkakasunud-sunod na natanggap sa kanila. . Ang gawaing inilagay sa pile na pinakahuling ay ang unang isasagawa. Ang pagbubuo ng mga elemento ng isang koleksyon sa ganitong paraan ay bumubuo ng isang stack . "

" Ang Java ay may espesyal na koleksyon para doon – Stack . Ito ay isang koleksyon na may mga pamamaraan para 'magdagdag ng isang elemento' at 'kumuha (kumuha) ng isang elemento'. Tulad ng maaaring nahulaan mo, ang elementong huling idinagdag ay ang unang makuha."

"Mukhang prangka."

"Great. Ngayon ipapaliwanag ko kung ano ang stack trace ."

"Isipin na sa isang Java program method A na tinatawag na method B , na tinatawag na method C , na tinatawag naman na method D . Upang lumabas sa method B , kailangan muna nating lumabas sa method C , at para magawa iyon – kailangan muna nating lumabas sa method D . Ito ang pag-uugali ay kahawig ng isang salansan."

"Bakit mo sinasabi na may hawig ito?"

"Upang makarating sa ilang gawain sa gitna ng aming stack ng mga papel, halimbawa, kailangan mo munang isagawa ang lahat ng mga gawain na nasa ibabaw nito."

"May pagkakatulad, ngunit hindi ako sigurado na naiintindihan ko nang tama ang lahat."

"Tingnan mo. Ang salansan ay isang hanay ng mga elemento. Parang mga piraso ng papel sa isang tumpok. Upang kunin ang ikatlong piraso ng papel mula sa itaas, kailangan mo munang kunin ang pangalawa, at para doon, kailangan mong kunin ang una. Ikaw maaaring palaging maglagay at kumuha ng mga piraso ng papel, ngunit kailangan mong kunin muna ang tuktok na papel."

"Gayundin ang totoo para sa mga function na tawag. Ang Paraan A ay tumatawag sa paraan B , na tumatawag sa paraan C . Upang lumabas sa A , kailangan mo munang lumabas sa B , at para magawa iyon, kailangan mong lumabas sa C ."

"Sandali. Kung naiintindihan ko ang sinasabi mo, ang buong konsepto ng isang stack ay kumukulo upang 'kunin ang piraso ng papel na huling idinagdag' at 'maaari ka lamang lumabas sa pamamaraang pinakahuling ipinasok mo'. Tama ba iyon? "

"Oo. Ang pagkakasunud-sunod ng mga tawag sa function ay kilala bilang 'call stack' o simpleng 'stack'. Ang huling function na tinawag ay ang unang function na magtatapos. Maghukay tayo sa isang halimbawa."

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. Nakukuha ko ang lahat tungkol sa mga function call. Ngunit ano ito StackTraceElement?"

"Sinusubaybayan ng Java Machine ang lahat ng function call. Para diyan, mayroon itong espesyal na koleksyon – ang stack. Kapag tumawag ang isang function sa isa pa, naglalagay ang Java Machine ng bagong StackTraceElement object sa stack. Kapag natapos ang isang function, aalisin ang elementong iyon. mula sa stack. Nangangahulugan ito na ang stack ay palaging nag-iimbak ng up-to-date na impormasyon tungkol sa kasalukuyang estado ng 'stack of function calls'. "

"Ang bawat StackTraceElement object ay naglalaman ng impormasyon tungkol sa tinatawag na method. Sa partikular, maaari mong makuha ang pangalan ng method gamit ang getMethodName method."

"Makikita mo kung paano ito gumagana sa halimbawa sa itaas:

1) Nakukuha namin ang stack ng tawag.

2) Gumagamit kami ng para sa bawat loop upang dumaan dito. Sana hindi mo nakalimutan kung ano yun.

3) Inilabas namin ang mga pangalan ng pamamaraan sa System.out ."

"Fascinating! At hindi rin masyadong kumplikado. Salamat, Rishi!"