ஸ்டேக் ட்ரேஸ்

1. ஸ்டேக் ட்ரேஸ் பெறுதல்

ஜாவா நிரலாக்க மொழி ஒரு புரோகிராமருக்கு ஒரு நிரலில் என்ன நடக்கிறது என்பது பற்றிய தகவல்களைப் பெற பல வழிகளை வழங்குகிறது. மற்றும் வெறும் வார்த்தைகள் அல்ல.

எடுத்துக்காட்டாக, C++ நிரல்கள் தொகுக்கப்பட்ட பிறகு, அவை இயந்திரக் குறியீடு நிறைந்த ஒரு பெரிய கோப்பாக மாறும், மேலும் இயக்க நேரத்தில் ஒரு புரோகிராமருக்குக் கிடைக்கக்கூடியது தற்போது இயக்கப்படும் இயந்திரக் குறியீட்டைக் கொண்ட நினைவகத் தொகுதியின் முகவரியாகும். நிறைய இல்லை, சொல்லலாம்.

ஜாவாவைப் பொறுத்தவரை, ஒரு நிரல் தொகுக்கப்பட்ட பிறகும், வகுப்புகள் வகுப்புகளாகவே இருக்கும், முறைகள் மற்றும் மாறிகள் மறைந்துவிடாது, மேலும் நிரலில் என்ன நடக்கிறது என்பது பற்றிய தகவல்களைப் பெற புரோகிராமருக்கு பல வழிகள் உள்ளன.

ஸ்டேக் ட்ரேஸ்

எடுத்துக்காட்டாக, ஒரு நிரலின் செயல்பாட்டின் கட்டத்தில், தற்போது செயல்படுத்தப்படும் முறையின் வகுப்பு மற்றும் பெயரை நீங்கள் கண்டுபிடிக்கலாம். ஒரு முறை மட்டுமல்ல - தற்போதைய முறையிலிருந்து முறைக்கு திரும்பும் முறை அழைப்புகளின் முழு சங்கிலி பற்றிய தகவலையும் பெறலாம் main().

தற்போதைய முறை மற்றும் அதை செயல்படுத்திய முறை மற்றும் அதை அழைக்கும் முறை போன்றவற்றை உள்ளடக்கிய பட்டியல் ஸ்டாக் ட்ரேஸ் எனப்படும் . இந்த அறிக்கையுடன் நீங்கள் அதைப் பெறலாம்:

StackTraceElement[] methods = Thread.currentThread().getStackTrace();

நீங்கள் அதை இரண்டு வரிகளாகவும் எழுதலாம்:

Thread current = Thread.currentThread();
StackTraceElement[] methods = current.getStackTrace();

currentThread()வகுப்பின் நிலையான முறையானது Threadஒரு பொருளுக்கு ஒரு குறிப்பை வழங்குகிறது Thread, இதில் தற்போதைய நூல் பற்றிய தகவல்கள் உள்ளன, அதாவது தற்போதைய செயல்படுத்தல் நூல். ஜாவா கோர் தேடலின் நிலைகள் 17 மற்றும் 18 இல் நூல்களைப் பற்றி மேலும் அறிந்து கொள்வீர்கள் .

இந்த Threadபொருளுக்கு ஒரு getStackTrace()முறை உள்ளது, இது பொருள்களின் வரிசையை வழங்குகிறது StackTraceElement, ஒவ்வொன்றும் ஒரு முறையைப் பற்றிய தகவல்களைக் கொண்டுள்ளது. ஒன்றாக எடுத்துக்கொண்டால், இந்த அனைத்து கூறுகளும் ஒரு அடுக்கு தடத்தை உருவாக்குகின்றன .

உதாரணமாக:

public class Main
{
   public static void main(String[] args)
   {
      test();
   }

   public static void test()
   {
      Thread current = Thread.currentThread();
      StackTraceElement[] methods = current.getStackTrace();

      for(var info: methods)
         System.out.println(info);
   }
}

java.base/java.lang.Thread.getStackTrace(Thread.java:1606)
Main.test(Main.java:11)
Main.main(Main.java:5)

எடுத்துக்காட்டின் கன்சோல் வெளியீட்டில் நாம் காணக்கூடியது போல, getStackTrace()முறை மூன்று கூறுகளின் வரிசையை வழங்கியது:

• getStackTrace()Threadவகுப்பின் முறை
• test()Mainவகுப்பின் முறை
• main()Mainவகுப்பின் முறை

இந்த ஸ்டாக் ட்ரேஸிலிருந்து, நாம் முடிவு செய்யலாம்:

• Main.java கோப்பின் 11வது வரியில் உள்ள முறையால் இந்த Thread.getStackTrace()முறை அழைக்கப்பட்டதுMain.test()
• Main.java கோப்பின் வரி 5ல் உள்ள முறையால் இந்த Main.test()முறை அழைக்கப்பட்டதுMain.main()
• யாரும் இந்த முறையை அழைக்கவில்லை Main.main()- இது அழைப்புகளின் சங்கிலியில் முதல் முறையாகும்.

மூலம், கிடைக்கக்கூடிய சில தகவல்கள் மட்டுமே திரையில் காட்டப்படும். StackTraceElementமற்ற அனைத்தும் பொருளிலிருந்து நேரடியாகப் பெறலாம்

2.StackTraceElement

அதன் பெயர் குறிப்பிடுவது போல, ஸ்டாக் டிரேஸ்StackTraceElement உறுப்பு பற்றிய தகவல்களைச் சேமிப்பதற்காக கிளாஸ் உருவாக்கப்பட்டது , அதாவது ஒரு முறை .stack trace

இந்த வகுப்பில் பின்வரும் நிகழ்வு முறைகள் உள்ளன:

String getClassName()

String getMethodName()

String getFileName()

int getLineNumber()

String getModuleName()

String getModuleVersion()

தற்போதைய அழைப்பு அடுக்கைப் பற்றிய முழுமையான தகவலைப் பெற அவை உங்களுக்கு உதவலாம்:

public class Main
{
   public static void main(String[] args)
   {
      test();
   }

   public static void test()
   {
      Thread current = Thread.currentThread();
      StackTraceElement[] methods = current.getStackTrace();

      for(StackTraceElement info: methods)
      {
         System.out.println(info.getClassName());
         System.out.println(info.getMethodName());

         System.out.println(info.getFileName());
         System.out.println(info.getLineNumber());

         System.out.println(info.getModuleName());
         System.out.println(info.getModuleVersion());
         System.out.println();
      }
   }
}

java.lang.Thread
getStackTrace
Thread.java
1606
java.base
11.0.2

Main
test
Main.java
11
null
null

Main
main
Main.java
5
null
null

3. அடுக்கு

ஸ்டாக் ட்ரேஸ் என்றால் என்ன என்பது உங்களுக்கு ஏற்கனவே தெரியும் , ஆனால் ஸ்டாக் (ஸ்டாக் கிளாஸ்) என்றால் என்ன?

அடுக்கு என்பது ஒரு தரவுக் கட்டமைப்பாகும், அதில் நீங்கள் கூறுகளைச் சேர்க்கலாம் மற்றும் அதில் இருந்து நீங்கள் கூறுகளை மீட்டெடுக்கலாம். அவ்வாறு செய்யும்போது, ​​​​நீங்கள் கடைசியில் இருந்து கூறுகளை மட்டுமே எடுக்க முடியும்: நீங்கள் முதலில் கடைசியாக சேர்த்ததை எடுத்துக் கொள்ளுங்கள், பின்னர் இரண்டாவது முதல் கடைசியாக சேர்த்தது போன்றவை.

ஸ்டேக் என்ற பெயரே இந்த நடத்தையை பரிந்துரைக்கிறது, காகிதங்களின் அடுக்கை நீங்கள் எவ்வாறு தொடர்புகொள்வீர்கள். நீங்கள் 1, 2 மற்றும் 3 தாள்களை ஒரு அடுக்கில் வைத்தால், அவற்றை தலைகீழ் வரிசையில் மீட்டெடுக்க வேண்டும்: முதலில் மூன்றாவது தாள், பின்னர் இரண்டாவது, பின்னர் மட்டுமே முதல்.

ஜாவாவில் அதே பெயர் மற்றும் நடத்தை கொண்ட ஒரு சிறப்பு அடுக்கு சேகரிப்பு வகுப்பு உள்ளது. ArrayListஇந்த வகுப்பு மற்றும் உடன் பல நடத்தைகளைப் பகிர்ந்து கொள்கிறது LinkedList. ஆனால் இது அடுக்கு நடத்தையை செயல்படுத்தும் முறைகளையும் கொண்டுள்ளது:

T push(T obj)

T pop()

T peek()

boolean empty()

int search(Object obj)

உதாரணமாக:

Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
int x = stack.pop();
stack.push(4);
int y = stack.peek();
stack.pop();
stack.pop();

[1]
[1, 2]
[1, 2, 3]
[1, 2]
[1, 2, 4]
[1, 2, 4]
[1, 2]
[1]

நிரலாக்கத்தில் அடுக்குகள் அடிக்கடி பயன்படுத்தப்படுகின்றன. எனவே இது பயனுள்ள தொகுப்பு.

4. விதிவிலக்கு கையாளுதலின் போது ஸ்டாக் ட்ரேஸைக் காண்பித்தல்

முறை அழைப்புகளின் பட்டியல் ஏன் ஸ்டாக் ட்ரேஸ் என்று அழைக்கப்படுகிறது ? ஏனென்றால், முறைகளின் பட்டியலை முறைப் பெயர்கள் கொண்ட காகிதத் தாள்களின் அடுக்காக நீங்கள் நினைத்தால், அடுத்த முறையை அழைக்கும் போது, ​​அந்த முறையின் பெயருடன் ஒரு தாளை அடுக்கி வைக்கிறீர்கள். அடுத்த தாள் அதன் மேல் செல்கிறது, மற்றும் பல.

ஒரு முறை முடிந்ததும், அடுக்கின் மேல் உள்ள தாள் அகற்றப்படும். மேலே உள்ள அனைத்து தாள்களையும் அகற்றாமல், அடுக்கின் நடுவில் இருந்து ஒரு தாளை அகற்ற முடியாது. இதேபோல், அழைப்புகளின் சங்கிலியின் நடுவில் உள்ள ஒரு முறையை அது அழைத்த அனைத்து முறைகளையும் நிறுத்தாமல் நீங்கள் அதை நிறுத்த முடியாது.

விதிவிலக்குகள்

விதிவிலக்கு கையாளுதலின் போது அடுக்குகளுக்கான மற்றொரு சுவாரஸ்யமான பயன்பாடு.

ஒரு நிரலில் ஒரு பிழை ஏற்பட்டு, ஒரு விதிவிலக்கு எறியப்படும் போது , ​​விதிவிலக்கு தற்போதைய ஸ்டாக் ட்ரேஸைக் கொண்டுள்ளது - முக்கிய முறையிலிருந்து தொடங்கி பிழை ஏற்பட்ட முறையுடன் முடிவடையும் முறைகளின் பட்டியலைக் கொண்ட ஒரு வரிசை. விதிவிலக்கு தூக்கி எறியப்பட்ட வரி கூட இருக்கிறது!

இந்த ஸ்டேக் டிரேஸ் விதிவிலக்குக்குள் சேமிக்கப்பட்டு, பின்வரும் முறையைப் பயன்படுத்தி அதிலிருந்து எளிதாகப் பெறலாம்:StackTraceElement[] getStackTrace()

உதாரணமாக:

try
{
   // An exception may occur here
}
catch(Exception e)
{
   StackTraceElement[] methods = e.getStackTrace()
}

இது வகுப்பின் ஒரு முறையாகும் Throwable, எனவே அதன் அனைத்து வழித்தோன்றல்களும் (அதாவது விதிவிலக்குகள்) getStackTrace()முறையைக் கொண்டுள்ளன. மிகவும் வசதியானது, இல்லையா?

விதிவிலக்கின் ஸ்டாக் ட்ரேஸைக் காட்டு

மூலம், Throwableவர்க்கம் ஸ்டாக் ட்ரேஸ்களுடன் வேலை செய்வதற்கான மற்றொரு முறையைக் கொண்டுள்ளது, இது விதிவிலக்குக்குள் சேமிக்கப்பட்ட அனைத்து ஸ்டேக் டிரேஸ் தகவலையும் காண்பிக்கும் ஒரு முறை. இது அழைக்கப்படுகிறது printStackTrace().

மிகவும் வசதியாக, நீங்கள் அதை எந்த விதிவிலக்கிலும் அழைக்கலாம்.

உதாரணமாக:

try
{
   // An exception may occur here
}
catch(Exception e)
{
   e.printStackTrace();
}

java.base/java.lang.Thread.getStackTrace(Thread.java:1606)
Main.test(Main.java:11)
Main.main(Main.java:5)