์ถ์ฒ
ChatGPT
StackOverflowError๋ ์๋ฐ ํ๋ก๊ทธ๋จ์์ ๋ฐ์ํ๋ ๋ฐํ์ ์๋ฌ๋ก, ํธ์ถ ์คํ์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ ๋ ๋ฐ์ํ๋ค. ์ด๋ ๋ณดํต ๋ฌดํ ์ฌ๊ท ํธ์ถ์ด๋ ๋๋ฌด ๊น์ ๋ฉ์๋ ํธ์ถ๋ก ์ธํด ์คํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ ๊ฐ๋ ๋ ๋ฐ์ํ๋ค.
StackOverflowError์ ์์ธ
1. ๋ฌดํ ์ฌ๊ท ํธ์ถ Infinite Recursion
์ฌ๊ท ํจ์๊ฐ ์ข ๋ฃ ์กฐ๊ฑด ์์ด ์์ ์ ๊ณ์ ํธ์ถํ ๋ ๋ฐ์ํ๋ค.
์๋ฅผ ๋ค์ด, ์๋ชป๋ ์ฌ๊ท ํธ์ถ์ด ์ข ๋ฃ๋์ง ์๊ณ ๊ณ์ ๋ฐ๋ณต๋๋ ๊ฒฝ์ฐ์ด๋ค.
public void recursiveMethod() {
recursiveMethod(); // ์ข
๋ฃ ์กฐ๊ฑด ์์ด ๊ณ์ ์์ ์ ํธ์ถ
}
2. ๋๋ฌด ๊น์ ์ฌ๊ท ํธ์ถ Too Deep Recursion
์ฌ๊ท ํธ์ถ์ด ์ข ๋ฃ ์กฐ๊ฑด์ด ์์ด๋, ์ฌ๊ท ๊น์ด๊ฐ ๋งค์ฐ ๊น์ด ์คํ์ด ์ด๊ณผ๋ ์ ์๋ค.
์๋ฅผ ๋ค์ด, ์ฌ๊ท ๊น์ด๊ฐ ๋๋ฌด ๊น์ด ์คํ ํ๋ ์์ ์ด๊ณผํ ๋ ๋ฐ์ํ๋ค.
public int factorial(int n) {
if (n == 1) return 1;
return n * factorial(n - 1);
}
// ํฐ ๊ฐ์ผ๋ก ํธ์ถํ ๊ฒฝ์ฐ, ๊น์ด๊ฐ ๋งค์ฐ ๊น์ด์ ธ StackOverflowError ๋ฐ์ ๊ฐ๋ฅ
3. ๋ฌดํ ๋ฃจํ์ ๊ฐ์ ์๋ชป๋ ๋ฐ๋ณต ๊ตฌ์กฐ
๋ฃจํ ๋ด์์ ๋ฉ์๋๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ฉด์ ์ข ๋ฃ ์กฐ๊ฑด์ด ์๊ฑฐ๋ ์กฐ๊ฑด์ด ์ ์ ํ๊ฒ ์ค์ ๋์ง ์์ผ๋ฉด ์คํ์ด ์ด๊ณผ๋ ์ ์๋ค.
StackOverflowError ํด๊ฒฐ ๋ฐฉ๋ฒ
1. ์ฌ๊ท ํจ์์ ์ข ๋ฃ ์กฐ๊ฑด ํ์ธ ๋ฐ ์์
์ฌ๊ท ํจ์๊ฐ ํญ์ ์ข ๋ฃ๋ ์ ์๋๋ก ์ ์ ํ ์ข ๋ฃ ์กฐ๊ฑด์ ์ค์ ํด์ผ ํ๋ค.
์ข ๋ฃ ์กฐ๊ฑด์ด ์ ๋๋ก ์ค์ ๋์๋์ง ํ์ธํ๊ณ , ์ข ๋ฃ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋ ๋ ์ฌ๊ท ํธ์ถ์ด ์ข ๋ฃ๋๋์ง ํ์ธํ๋ค.
public void recursiveMethod(int count) {
if (count == 0) return; // ์ข
๋ฃ ์กฐ๊ฑด์ ๋ช
ํํ ์ค์
recursiveMethod(count - 1);
}
2. ์ฌ๊ท ํธ์ถ ๊น์ด ์ค์ด๊ธฐ
์ฌ๊ท ํธ์ถ์ ๊น์ด๋ฅผ ์ค์ด๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์๊ณ ๋ฆฌ์ฆ์ ์ต์ ํํ๋ค.
์ฌ๊ท ํธ์ถ์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ณํํ๊ฑฐ๋, Tail Recursion Optimization(Tail Call Optimization)์ด ๊ฐ๋ฅํ๋ฉด ํ์ฉํ๋ค.
public int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
- ๊ด๋ จ ๊ธ -> [Kotlin][ํ๋ก๊ทธ๋๋ฐ ๊ฐ๋ ] Tail Recursion Optimization (Tail Call Optimization)
- ๊ด๋ จ ๊ธ -> [Java] Tail Recursion Optimization ๋์ฒด ๋ฐฉ๋ฒ
3. ๋ฉ๋ชจ์ด์ ์ด์ (Memoization) ์ฌ์ฉ
์ฌ๊ท ํธ์ถ์ ์ค๋ณต ๊ณ์ฐ์ ์ค์ด๊ธฐ ์ํด ๋ฉ๋ชจ์ด์ ์ด์ ๊ธฐ๋ฒ์ ์ฌ์ฉํด ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฐ์ ์ ์ฅํ๊ณ ์ฌ์ฌ์ฉํ๋ค.
์ด๋ ํนํ ํผ๋ณด๋์น ์์ด๊ณผ ๊ฐ์ ๊ณ์ฐ์ ์ ์ฉํ๋ค.
private static Map<Integer, Integer> memo = new HashMap<>();
public int fibonacci(int n) {
if (n <= 1) return n;
if (memo.containsKey(n)) return memo.get(n);
int result = fibonacci(n - 1) + fibonacci(n - 2);
memo.put(n, result);
return result;
}
4. ์คํ ํฌ๊ธฐ ๋๋ฆฌ๊ธฐ
StackOverflowError๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฌ๊ท ๊น์ด๋ฅผ ์ฆ๊ฐ์ํค๋ ๋์ , ์๋ฐ์ JVM ์ต์ ์ ์ฌ์ฉํด ์คํ ํฌ๊ธฐ๋ฅผ ๋๋ฆด ์ ์๋ค.
๋ช ๋ น์ค์์ -Xss ์ต์ ์ ์ฌ์ฉํด ์คํ ํฌ๊ธฐ๋ฅผ ์ง์ ํ๋ค.
java -Xss2m YourProgram
๊ทธ๋ฌ๋, ์คํ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๋ ๊ฒ์ ์์ ๋ฐฉํธ์ผ ๋ฟ ๊ทผ๋ณธ์ ์ธ ํด๊ฒฐ์ฑ ์ด ์๋๋ค. ํ๋ก๊ทธ๋จ ๋ก์ง์ ๊ฒํ ํด ์ฌ๊ท ๊น์ด๋ฅผ ์ค์ด๋ ๊ฒ์ด ๋ ์ข๋ค.
5. ๋ฌดํ ๋ฃจํ์ ๊ฐ์ ์๋ชป๋ ๋ฐ๋ณต ๊ตฌ์กฐ ์์
์ฝ๋ ๋ด์์ ์๋ชป๋ ์กฐ๊ฑด์ผ๋ก ์ธํด ๋ฐ๋ณต์ ์ผ๋ก ํธ์ถ๋๋ ๋ฉ์๋๊ฐ ์๋์ง ํ์ธํ๊ณ ์ด๋ฅผ ์์ ํ๋ค.
์์ฝ
StackOverflowError๋ ๋๋ถ๋ถ ์ฌ๊ท ํธ์ถ์ด ์๋ชป๋ ๊ฒฝ์ฐ์ ๋ฐ์ํ๋ค. ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ ์ฌ๊ท ํจ์์ ์ข ๋ฃ ์กฐ๊ฑด์ ๋ช ํํ ์ค์ ํ๊ณ , ์ฌ๊ท ๊น์ด๋ฅผ ์ค์ด๋ ๋ฐฉ๋ฒ์ ๊ณ ๋ คํด์ผ ํ๋ค. ๋ํ, ๋ฉ๋ชจ์ด์ ์ด์ ๊ณผ ๊ฐ์ ์ต์ ํ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ์ค๋ณต ๊ณ์ฐ์ ๋ฐฉ์งํ๊ณ , ํ์ํ ๊ฒฝ์ฐ JVM์ ์คํ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์๋ค. ๊ทผ๋ณธ์ ์ธ ํด๊ฒฐ์ฑ ์ ์ฝ๋๋ฅผ ์ต์ ํํ์ฌ ์คํ ์ฌ์ฉ๋์ ์ค์ด๋ ๊ฒ์ด๋ค.
'๋น ๊ตฌ๋ฉ ์ฑ์ฐ๊ธฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin][ํ๋ก๊ทธ๋๋ฐ ๊ฐ๋ ] Tail Recursion Optimization (Tail Call Optimization) (2) | 2024.08.28 |
---|---|
[Java] Tail Recursion Optimization ๋์ฒด ๋ฐฉ๋ฒ (0) | 2024.08.28 |
[Java] ์์ธ, ์๋ฌ (0) | 2024.08.27 |
[Java] ์ ๋ค๋ฆญ (1) | 2024.08.27 |
[Java] ๋ณ์ฑ Variance (0) | 2024.08.27 |