స్టాక్ ట్రేస్

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)