1. ์Šคํƒ ํŠธ๋ ˆ์ด์Šค ์–ป๊ธฐ

์Šคํƒ ์ถ”์  ๊ฐ€์ ธ์˜ค๊ธฐ

Java ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ํ”„๋กœ๊ทธ๋žจ์—์„œ ์ผ์–ด๋‚˜๋Š” ์ผ์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๋Š” ๋‹ค์–‘ํ•œ ๋ฐฉ๋ฒ•์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‹จ์ง€ ๋‹จ์–ด๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, C++ ํ”„๋กœ๊ทธ๋žจ์ด ์ปดํŒŒ์ผ๋œ ํ›„์—๋Š” ๊ธฐ๊ณ„ ์ฝ”๋“œ๋กœ ๊ฐ€๋“ ์ฐฌ ํ•˜๋‚˜์˜ ํฐ ํŒŒ์ผ์ด ๋˜๊ณ  ๋Ÿฐํƒ€์ž„์— ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์€ ํ˜„์žฌ ์‹คํ–‰ ์ค‘์ธ ๊ธฐ๊ณ„ ์ฝ”๋“œ๊ฐ€ ํฌํ•จ๋œ ๋ฉ”๋ชจ๋ฆฌ ๋ธ”๋ก์˜ ์ฃผ์†Œ๋ฟ์ž…๋‹ˆ๋‹ค. ๋งŽ์ด๋Š” ์•„๋‹™๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ Java์˜ ๊ฒฝ์šฐ ํ”„๋กœ๊ทธ๋žจ์ด ์ปดํŒŒ์ผ๋œ ํ›„์—๋„ ํด๋ž˜์Šค๋Š” ํด๋ž˜์Šค๋กœ ๋‚จ์•„ ์žˆ๊ณ  ๋ฉ”์„œ๋“œ์™€ ๋ณ€์ˆ˜๋Š” ์‚ฌ๋ผ์ง€์ง€ ์•Š์œผ๋ฉฐ ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ํ”„๋กœ๊ทธ๋žจ์—์„œ ์ผ์–ด๋‚˜๋Š” ์ผ์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๋Š” ์—ฌ๋Ÿฌ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค.

์Šคํƒ ์ถ”์ 

์˜ˆ๋ฅผ ๋“ค์–ด ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ์‹œ์ ์—์„œ ํ˜„์žฌ ์‹คํ–‰ ์ค‘์ธ ๋ฉ”์„œ๋“œ์˜ ํด๋ž˜์Šค์™€ ์ด๋ฆ„์„ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ํ•˜๋‚˜์˜ ๋ฉ”์„œ๋“œ๋งŒ์ด ์•„๋‹ˆ๋ผ ํ˜„์žฌ ๋ฉ”์„œ๋“œ์—์„œ ๋‹ค์‹œ ๋ฉ”์„œ๋“œ๋กœ ๋ฉ”์„œ๋“œ ํ˜ธ์ถœ์˜ ์ „์ฒด ์ฒด์ธ์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค main().

ํ˜„์žฌ ๋ฉ”์„œ๋“œ, ์ด๋ฅผ ํ˜ธ์ถœํ•œ ๋ฉ”์„œ๋“œ, ํ•ด๋‹น ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•œ ๋ฉ”์„œ๋“œ ๋“ฑ์œผ๋กœ ๊ตฌ์„ฑ๋œ ๋ชฉ๋ก์„ ์Šคํƒ ์ถ”์  ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค . ๋‹ค์Œ ๋ฌธ์žฅ์œผ๋กœ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

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

๋‘ ์ค„๋กœ ์ž‘์„ฑํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

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

currentThread()ํด๋ž˜์Šค์˜ ์ •์  ๋ฉ”์„œ๋“œ ๋Š” ํ˜„์žฌ ์Šค๋ ˆ๋“œ, ์ฆ‰ ํ˜„์žฌ ์‹คํ–‰ ์Šค๋ ˆ๋“œ์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ํฌํ•จํ•˜๋Š” ๊ฐœ์ฒด Thread์— ๋Œ€ํ•œ ์ฐธ์กฐ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค . Java CoreThread ํ€˜์ŠคํŠธ ์˜ ๋ ˆ๋ฒจ 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()
๋ชจ๋“ˆ์˜ ์ด๋ฆ„์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค(์ผ ์ˆ˜ ์žˆ์Œ null).
String getModuleVersion()
๋ชจ๋“ˆ์˜ ๋ฒ„์ „์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค(์ผ ์ˆ˜ ์žˆ์Œ null).

ํ˜„์žฌ ํ˜ธ์ถœ ์Šคํƒ์— ๋Œ€ํ•œ ๋ณด๋‹ค ์™„์ „ํ•œ ์ •๋ณด๋ฅผ ์–ป๋Š” ๋ฐ ๋„์›€์ด ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ์ฝ˜์†” ์ถœ๋ ฅ ๋ฉ”๋ชจ
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. ์Šคํƒ

์Šคํƒ ์ถ”์  ์ด ๋ฌด์—‡์ธ์ง€ ์ด๋ฏธ ์•Œ๊ณ  ์žˆ์ง€๋งŒ ์Šคํƒ (Stack ํด๋ž˜์Šค) ์ด ๋ฌด์—‡์ž…๋‹ˆ๊นŒ ?

์Šคํƒ์€ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ์š”์†Œ๋ฅผ ๊ฒ€์ƒ‰ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ์ž…๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋์—์„œ ์š”์†Œ๋งŒ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋จผ์ € ๋งˆ์ง€๋ง‰์œผ๋กœ ์ถ”๊ฐ€๋œ ์š”์†Œ๋ฅผ ๊ฐ€์ ธ์˜จ ๋‹ค์Œ ๋‘ ๋ฒˆ์งธ์—์„œ ๋งˆ์ง€๋ง‰์œผ๋กœ ์ถ”๊ฐ€๋œ ์š”์†Œ๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค.

์ด๋ฆ„ ์Šคํƒ ์ž์ฒด๋Š” ์ข…์ด ๋”๋ฏธ์™€ ์ƒํ˜ธ ์ž‘์šฉํ•˜๋Š” ๋ฐฉ์‹๊ณผ ๊ฐ™์€ ์ด ๋™์ž‘์„ ์ œ์•ˆํ•ฉ๋‹ˆ๋‹ค. ์‹œํŠธ 1, 2, 3์„ ์Šคํƒ์— ๋„ฃ์œผ๋ฉด ์—ญ์ˆœ์œผ๋กœ ํšŒ์ˆ˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋จผ์ € ์„ธ ๋ฒˆ์งธ ์‹œํŠธ, ๊ทธ ๋‹ค์Œ ๋‘ ๋ฒˆ์งธ ์‹œํŠธ, ๊ทธ๋ฆฌ๊ณ  ์ฒซ ๋ฒˆ์งธ ์‹œํŠธ๋งŒ.

Java์—๋Š” ๋™์ผํ•œ ์ด๋ฆ„๊ณผ ๋™์ž‘์„ ๊ฐ€์ง„ ํŠน๋ณ„ํ•œ Stack ์ปฌ๋ ‰์…˜ ํด๋ž˜์Šค๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ArrayList์ด ํด๋ž˜์Šค๋Š” ๋ฐ ์™€ ๋งŽ์€ ๋™์ž‘์„ ๊ณต์œ ํ•ฉ๋‹ˆ๋‹ค LinkedList. ๊ทธ๋Ÿฌ๋‚˜ ์Šคํƒ ๋™์ž‘์„ ๊ตฌํ˜„ํ•˜๋Š” ๋ฉ”์„œ๋“œ๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
T push(T obj)
obj์Šคํƒ์˜ ๋งจ ์œ„์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
T pop()
์Šคํƒ์˜ ๋งจ ์œ„์—์„œ ์š”์†Œ๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค(์Šคํƒ ๊นŠ์ด๊ฐ€ ๊ฐ์†Œํ•จ).
T peek()
์Šคํƒ์˜ ๋งจ ์œ„์— ์žˆ๋Š” ํ•ญ๋ชฉ์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค(์Šคํƒ์€ ๋ณ€๊ฒฝ๋˜์ง€ ์•Š์Œ).
boolean empty()
์ปฌ๋ ‰์…˜์ด ๋น„์–ด ์žˆ๋Š”์ง€ ํ™•์ธ
int search(Object obj)
์ปฌ๋ ‰์…˜์—์„œ ๊ฐœ์ฒด๋ฅผ ๊ฒ€์ƒ‰ํ•˜๊ณ  ํ•ด๋‹น ๊ฐœ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.index

์˜ˆ:

์•”ํ˜ธ ์Šคํƒ ๋‚ด์šฉ(์Šคํƒ์˜ ๋งจ ์œ„๋Š” ์˜ค๋ฅธ์ชฝ์— ์žˆ์Œ)
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()
}




Catch the exception

์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ์กด์žฌํ–ˆ๋˜ ์Šคํƒ ์ถ”์ ์„ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค.

์ด๊ฒƒ์€ ํด๋ž˜์Šค์˜ ๋ฉ”์„œ๋“œ 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)