Ver3.0 ๐ ์๋ฐ ํ๋กํ์ผ๋ง๊ณผ JProfiler VisualVM์ ํ์ฉํ ์ฑ๋ฅ ๋ถ์

๐ ์๋ฐ ํ๋กํ์ผ๋ง๊ณผ JProfiler VisualVM์ ํ์ฉํ ์ฑ๋ฅ ๋ถ์
์น๊ตฌ์ฒ๋ผ ์ฝ๊ฒ ๋ฐฐ์ฐ๋ ์๋ฐ ์ฑ๋ฅ ์ต์ ํ์ ๋ชจ๋ ๊ฒ
์ผ, ๋ ํน์ ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ๋๋ฆฌ๋ค๊ฐ ๊ฐ์๊ธฐ ๋๋ ค์ง๊ฑฐ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํฐ์ ธ๋ฒ๋ฆฐ ๊ฒฝํ ์์ด? ๐ฑ ๋๋ ์ฒ์์ ๊ทธ๋ฅ "์ปดํจํฐ๊ฐ ์ด์ํ๊ฐ?" ํ๊ณ ๋์ด๊ฐ๋๋ฐ, ์๊ณ ๋ณด๋๊น ๋ด ์ฝ๋์ ๋ฌธ์ ๊ฐ ์์๋ ๊ฑฐ์ผ. ๊ทธ๋๋ถํฐ ํ๋กํ์ผ๋ง์ด๋ผ๋ ๊ฑธ ์๊ฒ ๋๊ณ , ์ง์ง ๊ฒ์ ์ฒด์ธ์ ์์ด!
์ค๋์ ์๋ฐ ๊ฐ๋ฐ์๋ผ๋ฉด ๊ผญ ์์์ผ ํ ํ๋กํ์ผ๋ง๊ณผ ์ค์ ์์ ๋ฐ๋ก ์จ๋จน์ ์ ์๋ JProfiler, VisualVM ๊ฐ์ ๋๊ตฌ๋ค์ ๋ํด ์์ ์ฝ๊ฒ ์ค๋ช ํด์ค๊ฒ. ๋ง์น ์์์ ์น๊ตฌ๊ฐ ์๋ ค์ฃผ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ! ๐ฏ
๐ค ํ๋กํ์ผ๋ง์ด ๋ญ๋ฐ? ์ ํ์ํ ๊ฑฐ์ผ?
ํ๋กํ์ผ๋ง(Profiling)์ ์ฝ๊ฒ ๋งํด์ ํ๋ก๊ทธ๋จ์ ๊ฑด๊ฐ๊ฒ์ง์ด์ผ. ์ฐ๋ฆฌ๊ฐ ๋ณ์ ๊ฐ์ ํ์ก๊ฒ์ฌ, X-ray ์ฐ๋ฏ์ด, ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ๋ ์ด๋๊ฐ ์ํ์ง ์ฒดํฌํด์ผ ํ๊ฑฐ๋ . ๐ท
๐ฏ ํ๋กํ์ผ๋ง์ผ๋ก ์ ์ ์๋ ๊ฒ๋ค:
โข CPU ์ฌ์ฉ๋ฅ : ์ด๋ค ๋ฉ์๋๊ฐ CPU๋ฅผ ๋ง์ด ๋จน๊ณ ์๋์ง
โข ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋: ์ด๋ค ๊ฐ์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ๊ณ ์๋์ง
โข ์ค๋ ๋ ์ํ: ์ค๋ ๋๋ค์ด ๋ญ ํ๊ณ ์๋์ง, ๋ฐ๋๋ฝ์ ์๋์ง
โข ๊ฐ๋น์ง ์ปฌ๋ ์
: GC๊ฐ ์ผ๋ง๋ ์์ฃผ ์ผ์ด๋๋์ง
โข I/O ์์
: ํ์ผ์ด๋ ๋คํธ์ํฌ ์์
์ด ์ผ๋ง๋ ๊ฑธ๋ฆฌ๋์ง
์ค์ ๋ก ๋ด๊ฐ ์์ ์ ๋ง๋ ์น ์ ํ๋ฆฌ์ผ์ด์ ์ด ์์๋๋ฐ, ์ฌ์ฉ์๊ฐ 100๋ช ๋ง ๋์ด๊ฐ๋ฉด ์๋ฒ๊ฐ ์ฃฝ์ด๋ฒ๋ฆฌ๋ ๊ฑฐ์ผ. ๐ญ ์ฒ์์ ์๋ฒ ์คํ์ด ๋ถ์กฑํ ์ค ์๊ณ AWS ์ธ์คํด์ค๋ฅผ ์ ๊ทธ๋ ์ด๋ํ๋๋ฐ๋ ๋๊ฐ๋๋ผ๊ณ . ๊ทธ๋์ ํ๋กํ์ผ๋ง ํด์ ๋๋ ค๋ดค๋๋, ํ ๋ฉ์๋์์ ๋ฌดํ ๋ฃจํ์ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ์ด ๋๊ณ ์์์ด. ๊ทธ๊ฑฐ ํ๋ ๊ณ ์ณค๋๋ 500๋ช ๋ ๊ฑฐ๋ฌํ๋๋ผ! ๐ช
๐ ํ๋กํ์ผ๋ง์ ๋ ๊ฐ์ง ๋ฐฉ์
ํ๋กํ์ผ๋ง์๋ ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉ์์ด ์์ด:
1๏ธโฃ ์ํ๋ง(Sampling)
์ผ์ ์๊ฐ๋ง๋ค ์ค๋ ์ท์ ์ฐ๋ ๋ฐฉ์์ด์ผ. ๋ง์น CCTV๊ฐ 1์ด๋ง๋ค ์ฌ์ง์ ์ฐ๋ ๊ฒ์ฒ๋ผ. ์ค๋ฒํค๋๊ฐ ์ ์ด์ ํ๋ก๋์ ํ๊ฒฝ์์๋ ์ธ ์ ์์ด. ๋ค๋ง ์ ํ๋๋ ์กฐ๊ธ ๋จ์ด์ง ์ ์์ง.
2๏ธโฃ ๊ณ์ธก(Instrumentation)
๋ชจ๋ ๋ฉ์๋ ํธ์ถ์ ๋ค ๊ธฐ๋กํ๋ ๋ฐฉ์์ด์ผ. ์์ ์ ํํ์ง๋ง, ๊ทธ๋งํผ ํ๋ก๊ทธ๋จ์ด ๋๋ ค์ ธ. ๊ฐ๋ฐ ํ๊ฒฝ์์ ๋ํ ์ผํ๊ฒ ๋ถ์ํ ๋ ์ข์.
๐ ๏ธ JProfiler: ํ๋กํ์ ๋์ ์ ํ
JProfiler๋ ์ ๋ฃ ํด์ด๊ธด ํ๋ฐ, ์ง์ง ๊ฐ๋ ฅํด. ๋ด๊ฐ ์ฒ์ ์จ๋ดค์ ๋ "์, ์ด๋ฐ ๊ฒ ๋ค ๋ณด์ด๋ค?" ํ๊ณ ๊ฐํํ๊ฑฐ๋ . ๐คฉ ํนํ ์์ฉ ํ๋ก์ ํธ์์ ๋ณต์กํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๋ ๋น์ ๋ฐํด.
๐จ JProfiler์ ์ฃผ์ ๊ธฐ๋ฅ๋ค
1. CPU ํ๋กํ์ผ๋ง - ๋๋ฆฐ ์ฝ๋ ์ฐพ๊ธฐ
JProfiler๋ฅผ ์คํํ๋ฉด ์ ์ผ ๋จผ์ ๋ณด์ด๋ ๊ฒ CPU ๋ทฐ์ผ. ์ฌ๊ธฐ์ Call Tree๋ฅผ ๋ณด๋ฉด ์ด๋ค ๋ฉ์๋๊ฐ ์ผ๋ง๋ ์ค๋ ๊ฑธ๋ ธ๋์ง ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ๋ณด์ฌ์ค.
// JProfiler๋ก ๋ถ์ํ๊ธฐ ์ข์ ์์ ์ฝ๋
public class PerformanceTest {
public void slowMethod() {
// ์ด ๋ฉ์๋๊ฐ ๋๋ฆฌ๋ค๋ฉด JProfiler๊ฐ ๋ฐ๋ก ์ฐพ์์ค
for (int i = 0; i < 1000000; i++) {
String result = heavyCalculation(i);
}
}
private String heavyCalculation(int num) {
// ๋ณต์กํ ๊ณ์ฐ
return String.valueOf(Math.pow(num, 2));
}
}
JProfiler๋ฅผ ๋ถ์ด๊ณ ์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด, slowMethod()๊ฐ ์ ์ฒด ์คํ ์๊ฐ์ ๋ช ํผ์ผํธ๋ฅผ ์ฐจ์งํ๋์ง ์ ํํ ๋ณด์ฌ์ค. Hot Spots ๋ทฐ์์๋ ๊ฐ์ฅ ๋ง์ด ํธ์ถ๋ ๋ฉ์๋ ์์ผ๋ก ์ ๋ ฌ๋ ํด์ฃผ๊ณ !
โ ๏ธ ์ค์ ํ: CPU ํ๋กํ์ผ๋งํ ๋๋ Thread Status๋ ๊ฐ์ด ๋ด์ผ ํด. ๋ฉ์๋๊ฐ ๋๋ฆฐ ๊ฒ ์๋๋ผ ๋ฝ(Lock) ๋๋ฌธ์ ๋๊ธฐํ๊ณ ์์ ์๋ ์๊ฑฐ๋ !
2. ๋ฉ๋ชจ๋ฆฌ ํ๋กํ์ผ๋ง - ๋ฉ๋ชจ๋ฆฌ ๋์ ์ก๊ธฐ
๋ฉ๋ชจ๋ฆฌ ๋์๋ ์ง์ง ๊ณจ์น ์ํ ๋ฌธ์ ์ผ. ์ฒ์์ ๊ด์ฐฎ๋ค๊ฐ ์๊ฐ์ด ์ง๋๋ฉด์ ์ ์ ๋๋ ค์ง๊ณ , ๊ฒฐ๊ตญ OutOfMemoryError๋ก ํฐ์ ธ๋ฒ๋ฆฌ๊ฑฐ๋ . ๐ฑ
JProfiler์ Heap Walker๋ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ์ฐพ๋ ๋ฐ ์ต๊ณ ์ผ. ํ ๋คํ๋ฅผ ๋ ์ ์ด๋ค ๊ฐ์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ง์ด ์ฐจ์งํ๋์ง, ๊ทธ ๊ฐ์ฒด๋ฅผ ๋๊ฐ ์ฐธ์กฐํ๊ณ ์๋์ง ๋ค ๋ณด์ฌ์ค.
// ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ ์ ์๋ ์ฝ๋
public class MemoryLeakExample {
private static List<byte[]> leakyList = new ArrayList<>();
public void addData() {
// ์ด๋ ๊ฒ ๊ณ์ ์ถ๊ฐ๋ง ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ํฐ์ ธ!
leakyList.add(new byte[1024 * 1024]); // 1MB์ฉ ์ถ๊ฐ
}
// ํด๊ฒฐ์ฑ
: ์ ์ ํ ์์ ์ clear() ํธ์ถ
public void cleanup() {
leakyList.clear();
}
}
JProfiler๋ก ์ด ์ฝ๋๋ฅผ ๋ถ์ํ๋ฉด byte[] ๋ฐฐ์ด์ด ๊ณ์ ์์ด๋ ๊ฒ ๋ณด์ฌ. Allocation Hot Spots์์๋ ์ด๋์ ๊ฐ์ฒด๊ฐ ์์ฑ๋๋์ง๋ ์๋ ค์ฃผ๊ณ !
๐ JProfiler ์ค์ ํ์ฉ๋ฒ
Step 1: JProfiler ์ฐ๊ฒฐํ๊ธฐ
JProfiler๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ ๊ฐ์ง์ผ:
๋ก์ปฌ ์ ํ๋ฆฌ์ผ์ด์ ํ๋กํ์ผ๋ง:
1. JProfiler ์คํ
2. "New Session" ํด๋ฆญ
3. "Attach to local JVM" ์ ํ
4. ์คํ ์ค์ธ ์๋ฐ ํ๋ก์ธ์ค ์ ํ
์๊ฒฉ ์๋ฒ ํ๋กํ์ผ๋ง:
์๋ฒ ์์ ์ JVM ์ต์ ์ถ๊ฐ:
java -agentpath:/path/to/jprofiler/bin/linux-x64/libjprofilerti.so=port=8849 \
-jar your-application.jar
๊ทธ๋ฌ๋ฉด JProfiler์์ ์๊ฒฉ์ผ๋ก ์ ์ํ ์ ์์ด. ํ๋ก๋์ ์๋ฒ๋ฅผ ์ง์ ํ๋กํ์ผ๋งํ ์ ์๋ค๋ ๊ฒ ์ง์ง ํฐ ์ฅ์ ์ด์ผ! ๐ฏ
Step 2: ๋ฐ์ดํฐ ์์ง ๋ฐ ๋ถ์
ํ๋กํ์ผ๋ง์ ์์ํ๋ฉด ์ค์๊ฐ์ผ๋ก ๋ฐ์ดํฐ๊ฐ ์์ฌ. ๋ด๊ฐ ์์ฃผ ์ฐ๋ ๋ถ์ ์์๋ ์ด๋:
๐ ๋๋ง์ ๋ถ์ ๋ฃจํด:
1. Telemetries์์ ์ ์ฒด์ ์ธ CPU/๋ฉ๋ชจ๋ฆฌ ์ถ์ด ํ์ธ
2. CPU Views โ Hot Spots์์ ๋๋ฆฐ ๋ฉ์๋ ์ฐพ๊ธฐ
3. Call Tree๋ก ํธ์ถ ๊ฒฝ๋ก ์ถ์
4. Memory โ All Objects์์ ๋ฉ๋ชจ๋ฆฌ ๋ง์ด ์ฐ๋ ๊ฐ์ฒด ํ์ธ
5. Heap Walker๋ก ๊ฐ์ฒด ์ฐธ์กฐ ๊ด๊ณ ๋ถ์
Step 3: ์ค๋ ์ท ์ ์ฅ ๋ฐ ๋น๊ต
JProfiler์ ๊ฟํ ์ค ํ๋๋ ์ค๋ ์ท ๋น๊ต ๊ธฐ๋ฅ์ด์ผ. ์ฝ๋๋ฅผ ์์ ํ๊ธฐ ์ ํ์ ์ค๋ ์ท์ ์ฐ์ด์ ๋น๊ตํ๋ฉด, ์ฑ๋ฅ์ด ์ผ๋ง๋ ๊ฐ์ ๋๋์ง ํ๋์ ๋ณด์ฌ!
// ๊ฐ์ ์ ์ฝ๋
public List<User> getUsers() {
List<User> users = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
User user = database.findById(i); // ๋งค๋ฒ DB ์กฐํ!
users.add(user);
}
return users;
}
// ๊ฐ์ ํ ์ฝ๋
public List<User> getUsers() {
// ํ ๋ฒ์ ์กฐํ
return database.findAllByIdBetween(0, 10000);
}
์ด๋ฐ ์์ผ๋ก ๊ฐ์ ํ๊ณ ์ค๋ ์ท์ ๋น๊ตํ๋ฉด, DB ํธ์ถ ํ์๊ฐ 10,000๋ฒ์์ 1๋ฒ์ผ๋ก ์ค์ด๋ ๊ฒ ๋ช ํํ ๋ณด์ฌ. ์คํ ์๊ฐ๋ ๋ช ์ด์์ ๋ฐ๋ฆฌ์ด ๋จ์๋ก ํ ์ค์ด๋ค๊ณ ! โก
๐ VisualVM: ๋ฌด๋ฃ๋ก ์์ํ๋ ํ๋กํ์ผ๋ง
JProfiler๊ฐ ์ข๊ธด ํ๋ฐ ์ ๋ฃ์์? ๋์ด ์๊ฑฐ๋ ๊ฐ๋จํ ๋ถ์๋ง ํ์ํ๋ค๋ฉด VisualVM์ด ๋ฑ์ด์ผ! JDK์ ํฌํจ๋์ด ์์ด์ ๋ณ๋ ์ค์น๋ ํ์ ์๊ณ , ๋ฌด๋ฃ์ธ๋ฐ๋ ๊ธฐ๋ฅ์ด ๊ฝค ๊ฐ๋ ฅํด. ๐
๐ฏ VisualVM ์์ํ๊ธฐ
VisualVM์ JDK 8๊น์ง๋ ๊ธฐ๋ณธ ํฌํจ์ด์๋๋ฐ, JDK 9๋ถํฐ๋ ๋ณ๋๋ก ๋ค์ด๋ฐ์์ผ ํด. ํ์ง๋ง ์ค์น๋ ์ง์ง ์ฌ์:
์ค์น ๋ฐฉ๋ฒ:
1. https://visualvm.github.io ์ ์
2. ์ต์ ๋ฒ์ ๋ค์ด๋ก๋
3. ์์ถ ํ๊ณ bin/visualvm ์คํ
์คํํ๋ฉด ์ผ์ชฝ์ ๋ก์ปฌ์์ ๋์๊ฐ๋ ์๋ฐ ํ๋ก์ธ์ค๋ค์ด ์ญ ๋์. ๊ฑฐ๊ธฐ์ ๋ถ์ํ๊ณ ์ถ์ ํ๋ก์ธ์ค๋ฅผ ๋๋ธํด๋ฆญํ๋ฉด ๋! ๐
๐ VisualVM์ ํต์ฌ ๊ธฐ๋ฅ๋ค
1. Monitor ํญ - ์ค์๊ฐ ๋ชจ๋ํฐ๋ง
Monitor ํญ์ ๋ง ๊ทธ๋๋ก ์ค์๊ฐ์ผ๋ก ์ ํ๋ฆฌ์ผ์ด์ ์ํ๋ฅผ ๋ณด์ฌ์ค. CPU ์ฌ์ฉ๋ฅ , ํ ๋ฉ๋ชจ๋ฆฌ, ํด๋์ค ๋ก๋ฉ, ์ค๋ ๋ ์ ๋ฑ์ด ๊ทธ๋ํ๋ก ์ญ์ญ ๊ทธ๋ ค์ ธ.
๐ก Monitor ํญ ํ์ฉ ํ:
โข Heap ๊ทธ๋ํ: ํฑ๋ ๋ชจ์์ด ์ ์์ด์ผ. ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฐจ๋ฉด GC๊ฐ ์ผ์ด๋์ ํ ๋จ์ด์ง๊ฑฐ๋ . ๋ง์ฝ ๊ณ์ ์ฌ๋ผ๊ฐ๊ธฐ๋ง ํ๋ค๋ฉด? ๋ฉ๋ชจ๋ฆฌ ๋์ ์์ฌ!
โข Perform GC ๋ฒํผ: ๊ฐ์ ๋ก GC๋ฅผ ์คํ์ํฌ ์ ์์ด. ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ๋ง ์ ์ค์ด๋๋์ง ํ์ธํ ๋ ์ ์ฉํด.
โข Heap Dump ๋ฒํผ: ํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ํ๋ฅผ ์ค๋
์ท์ผ๋ก ์ ์ฅ. ๋์ค์ ์์ธํ ๋ถ์ํ ์ ์์ด.
2. Threads ํญ - ์ค๋ ๋ ์ํ ๋ถ์
๋ฉํฐ์ค๋ ๋ ํ๋ก๊ทธ๋๋ฐํ ๋ ์ง์ง ์ ์ฉํด. ๊ฐ ์ค๋ ๋๊ฐ Running์ธ์ง, Waiting์ธ์ง, Blocked์ธ์ง ์๊น๋ก ๋ณด์ฌ์ค.
// ๋ฐ๋๋ฝ์ด ๋ฐ์ํ ์ ์๋ ์ฝ๋
public class DeadlockExample {
private final Object lock1 = new Object();
private final Object lock2 = new Object();
public void method1() {
synchronized (lock1) {
System.out.println("Lock1 ํ๋");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (lock2) {
System.out.println("Lock2 ํ๋");
}
}
}
public void method2() {
synchronized (lock2) {
System.out.println("Lock2 ํ๋");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (lock1) {
System.out.println("Lock1 ํ๋");
}
}
}
}
์ด๋ฐ ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ฐ๋๋ฝ์ด ๋ฐ์ํ ์ ์์ด. VisualVM์ Threads ํญ์์ "Detect Deadlock" ๋ฒํผ์ ๋๋ฅด๋ฉด ๋ฐ๋๋ฝ์ ์๋์ผ๋ก ์ฐพ์์ค! ์ด๋ค ์ค๋ ๋๋ค์ด ์๋ก๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋์ง๋ ๋ณด์ฌ์ฃผ๊ณ . ๐
3. Sampler ํญ - ๊ฐ๋ฒผ์ด ํ๋กํ์ผ๋ง
Sampler๋ ์ํ๋ง ๋ฐฉ์์ผ๋ก ํ๋กํ์ผ๋ง์ ํด. ์ค๋ฒํค๋๊ฐ ์ ์ด์ ํ๋ก๋์ ํ๊ฒฝ์์๋ ๋ถ๋ด ์์ด ์ธ ์ ์์ด.
CPU ์ํ๋ง:
โข "CPU" ๋ฒํผ ํด๋ฆญํ๋ฉด ์์
โข ์ผ์ ์๊ฐ ๋์ ์คํ
โข "Stop" ๋ฒํผ์ผ๋ก ์ค์ง
โข Hot spots์์ ๊ฐ์ฅ ๋ง์ด ์คํ๋ ๋ฉ์๋ ํ์ธ
๋ด๊ฐ ์ค์ ๋ก ๊ฒฝํํ ์ผ์ด์ค๋ฅผ ํ๋ ๋ค์ด์ค๊ฒ. ์ด๋ค REST API๊ฐ ํ๊ท ์๋ต์๊ฐ์ด 2์ด๋ ๊ฑธ๋ ธ์ด. Sampler๋ก ๋๋ ค๋ดค๋๋ JSON ์ง๋ ฌํํ๋ ๋ถ๋ถ์์ ์๊ฐ์ ์์ฒญ ์ก์๋จน๊ณ ์๋๋ผ๊ณ . ์๊ณ ๋ณด๋ ์ํ ์ฐธ์กฐ ๋๋ฌธ์ ๋ฌดํ ๋ฃจํ์ ๋น ์ง ๊ฑฐ์์ด. ๐
// ์ํ ์ฐธ์กฐ ๋ฌธ์
@Entity
public class User {
@OneToMany(mappedBy = "user")
private List<Order> orders;
}
@Entity
public class Order {
@ManyToOne
private User user;
}
// JSON ์ง๋ ฌํ ์ User โ Order โ User โ Order ... ๋ฌดํ ๋ฐ๋ณต!
// ํด๊ฒฐ์ฑ
: @JsonManagedReference์ @JsonBackReference ์ฌ์ฉ
@Entity
public class User {
@OneToMany(mappedBy = "user")
@JsonManagedReference
private List<Order> orders;
}
@Entity
public class Order {
@ManyToOne
@JsonBackReference
private User user;
}
4. Profiler ํญ - ์ ๋ฐ ํ๋กํ์ผ๋ง
Profiler๋ ๊ณ์ธก ๋ฐฉ์์ด๋ผ ๋ ์ ํํด. ๋ชจ๋ ๋ฉ์๋ ํธ์ถ์ ๋ค ๊ธฐ๋กํ๊ฑฐ๋ . ๋์ ํ๋ก๊ทธ๋จ์ด ๋๋ ค์ง ์ ์์ผ๋ ๊ฐ๋ฐ ํ๊ฒฝ์์๋ง ์ฐ๋ ๊ฒ ์ข์.
โ ๏ธ ์ฃผ์์ฌํญ: Profiler๋ฅผ ์ผ๋ฉด ์ ํ๋ฆฌ์ผ์ด์ ์ด ํ์๋ณด๋ค 2~10๋ฐฐ ์ ๋ ๋๋ ค์ง ์ ์์ด. ํ๋ก๋์ ์์๋ ์ ๋ ์ฐ์ง ๋ง!
๐ VisualVM ํ๋ฌ๊ทธ์ธ ํ์ฉํ๊ธฐ
VisualVM์ ์จ๊ฒจ์ง ๋ณด์์ ๋ฐ๋ก ํ๋ฌ๊ทธ์ธ ์์คํ ์ด์ผ. Tools โ Plugins ๋ฉ๋ด์์ ๋ค์ํ ํ๋ฌ๊ทธ์ธ์ ์ค์นํ ์ ์์ด.
์ถ์ฒ ํ๋ฌ๊ทธ์ธ:
โข VisualGC: ๊ฐ๋น์ง ์ปฌ๋ ์
์ ์๊ฐ์ ์ผ๋ก ๋ณด์ฌ์ค. Eden, Survivor, Old Generation์ด ์ด๋ป๊ฒ ๋ณํ๋์ง ์ค์๊ฐ์ผ๋ก ๋ณผ ์ ์์ด.
โข BTrace: ์คํ ์ค์ธ ์ ํ๋ฆฌ์ผ์ด์
์ ๋์ ์ผ๋ก ์ฝ๋๋ฅผ ์ฃผ์
ํ ์ ์์ด. ์ฌ์์ ์์ด ๋๋ฒ๊น
๊ฐ๋ฅ!
โข Threads Inspector: ์ค๋ ๋ ๋คํ๋ฅผ ๋ ์์ธํ ๋ถ์ํ ์ ์์ด.
โก ์ค์ ์ฑ๋ฅ ์ต์ ํ ์ฌ๋ก
์ด๋ก ๋ง ์๋ฉด ๋ญํด, ์ค์ ์์ ์จ๋จน์ด์ผ์ง! ๋ด๊ฐ ์ค์ ๋ก ๊ฒช์๋ ์ฑ๋ฅ ๋ฌธ์ ๋ค๊ณผ ํด๊ฒฐ ๊ณผ์ ์ ๊ณต์ ํ ๊ฒ. ๐ฏ
์ฌ๋ก 1: N+1 ์ฟผ๋ฆฌ ๋ฌธ์
์ด๊ฑด ์ง์ง ํํ ๋ฌธ์ ์ผ. JPA ์ธ ๋ ํนํ ์กฐ์ฌํด์ผ ํด.
// ๋ฌธ์ ๊ฐ ๋๋ ์ฝ๋
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List<UserDTO> getAllUsers() {
List<User> users = userRepository.findAll(); // 1๋ฒ์ ์ฟผ๋ฆฌ
return users.stream()
.map(user -> {
// ๊ฐ user๋ง๋ค orders๋ฅผ ์กฐํ (N๋ฒ์ ์ฟผ๋ฆฌ!)
List<Order> orders = user.getOrders();
return new UserDTO(user, orders);
})
.collect(Collectors.toList());
}
}
// ์ฌ์ฉ์๊ฐ 100๋ช
์ด๋ฉด ์ด 101๋ฒ์ ์ฟผ๋ฆฌ๊ฐ ์คํ๋ผ!
// 1๋ฒ(users ์กฐํ) + 100๋ฒ(๊ฐ user์ orders ์กฐํ)
VisualVM์ผ๋ก ํ๋กํ์ผ๋งํ๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ด๋ จ ๋ฉ์๋์์ ์๊ฐ์ ์์ฒญ ์ก์๋จน๋ ๊ฒ ๋ณด์ฌ. ๋ก๊ทธ๋ฅผ ํ์ธํด๋ณด๋ ์ฟผ๋ฆฌ๊ฐ 100๋ฒ ๋๊ฒ ๋ ์๊ฐ๊ณ ์๋๋ผ๊ณ ! ๐ฑ
// ํด๊ฒฐ์ฑ
: Fetch Join ์ฌ์ฉ
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();
}
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List<UserDTO> getAllUsers() {
// ์ด์ 1๋ฒ์ ์ฟผ๋ฆฌ๋ก ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์!
List<User> users = userRepository.findAllWithOrders();
return users.stream()
.map(user -> new UserDTO(user, user.getOrders()))
.collect(Collectors.toList());
}
}
// ์ฟผ๋ฆฌ ํ์: 101๋ฒ โ 1๋ฒ
// ์๋ต ์๊ฐ: 2.5์ด โ 0.3์ด
์ด๋ ๊ฒ ๊ณ ์น๋๊น ์๋ต ์๊ฐ์ด 8๋ฐฐ ์ด์ ๋นจ๋ผ์ก์ด! ๐
์ฌ๋ก 2: ๋ถํ์ํ ๊ฐ์ฒด ์์ฑ
JProfiler๋ก ๋ฉ๋ชจ๋ฆฌ ํ๋กํ์ผ๋ง์ ํ๋ค๊ฐ ๋ฐ๊ฒฌํ ๋ฌธ์ ์ผ. String ๊ฐ์ฒด๊ฐ ๋น์ ์์ ์ผ๋ก ๋ง์ด ์์ฑ๋๊ณ ์๋๋ผ๊ณ .
// ๋ฌธ์ ๊ฐ ๋๋ ์ฝ๋
public String generateReport(List<Data> dataList) {
String report = "";
for (Data data : dataList) {
report += data.toString() + "\n"; // ๋งค๋ฒ ์๋ก์ด String ๊ฐ์ฒด ์์ฑ!
}
return report;
}
// dataList๊ฐ 10,000๊ฐ๋ฉด String ๊ฐ์ฒด๋ 10,000๊ฐ ์์ฑ๋ผ
// String์ ๋ถ๋ณ์ด๋ผ + ์ฐ์ฐํ ๋๋ง๋ค ์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ฑฐ๋
JProfiler์ Allocation Hot Spots๋ฅผ ๋ณด๋๊น ์ด ๋ฉ์๋์์ String ๊ฐ์ฒด๊ฐ ํญ๋ฐ์ ์ผ๋ก ์์ฑ๋๊ณ ์์์ด. ๋ฉ๋ชจ๋ฆฌ๋ ๋ฉ๋ชจ๋ฆฌ์ง๋ง, GC๋ ๊ณ์ ์ผ์ด๋์ CPU๊น์ง ์ก์๋จน๊ณ ์๋๋ผ.
// ํด๊ฒฐ์ฑ
: StringBuilder ์ฌ์ฉ
public String generateReport(List<Data> dataList) {
StringBuilder report = new StringBuilder();
for (Data data : dataList) {
report.append(data.toString()).append("\n");
}
return report.toString();
}
// ๋๋ Java 8 ์คํ์ผ๋ก
public String generateReport(List<Data> dataList) {
return dataList.stream()
.map(Data::toString)
.collect(Collectors.joining("\n"));
}
// ์คํ ์๊ฐ: 5.2์ด โ 0.8์ด
// ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋: 500MB โ 50MB
์ด๊ฒ๋ ์์ฒญ๋ ๊ฐ์ ์ด์์ด. ํนํ ๋ฉ๋ชจ๋ฆฌ๊ฐ 10๋ถ์ 1๋ก ์ค์ด๋ค์์ด! ๐ช
์ฌ๋ก 3: ๋๊ธฐํ ๋ณ๋ชฉ
๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ synchronized ํค์๋๋ฅผ ๋จ๋ฐํ๋ฉด ์ฑ๋ฅ์ด ํ ๋จ์ด์ ธ.
// ๋ฌธ์ ๊ฐ ๋๋ ์ฝ๋
public class CacheManager {
private Map<String, Object> cache = new HashMap<>();
// ๋ชจ๋ ๋ฉ์๋๊ฐ synchronized
public synchronized void put(String key, Object value) {
cache.put(key, value);
}
public synchronized Object get(String key) {
return cache.get(key);
}
public synchronized void remove(String key) {
cache.remove(key);
}
}
// ์ฝ๊ธฐ ์์
์ด ๋๋ถ๋ถ์ธ๋ฐ๋ ๋ฝ์ ์ก์์ ๋ณ๋ชฉ ๋ฐ์!
VisualVM์ Threads ํญ์ ๋ณด๋๊น ์ค๋ ๋๋ค์ด ๋๋ถ๋ถ BLOCKED ์ํ๋๋ผ๊ณ . ์๋ก ๋ฝ์ ๊ธฐ๋ค๋ฆฌ๋๋ผ ์๊ฐ์ ๋ญ๋นํ๊ณ ์์์ด.
// ํด๊ฒฐ์ฑ
1: ConcurrentHashMap ์ฌ์ฉ
public class CacheManager {
private Map<String, Object> cache = new ConcurrentHashMap<>();
// synchronized ์ ๊ฑฐ!
public void put(String key, Object value) {
cache.put(key, value);
}
public Object get(String key) {
return cache.get(key);
}
public void remove(String key) {
cache.remove(key);
}
}
// ํด๊ฒฐ์ฑ
2: ReadWriteLock ์ฌ์ฉ
public class CacheManager {
private Map<String, Object> cache = new HashMap<>();
private ReadWriteLock lock = new ReentrantReadWriteLock();
public void put(String key, Object value) {
lock.writeLock().lock();
try {
cache.put(key, value);
} finally {
lock.writeLock().unlock();
}
}
public Object get(String key) {
lock.readLock().lock(); // ์ฝ๊ธฐ๋ ๋์์ ๊ฐ๋ฅ!
try {
return cache.get(key);
} finally {
lock.readLock().unlock();
}
}
}
// ๋์ ์ฒ๋ฆฌ๋: 100 req/sec โ 1,500 req/sec
๋์ ์ฒ๋ฆฌ๋์ด 15๋ฐฐ๋ ์ฆ๊ฐํ์ด! ์ด๊ฒ ๋ฐ๋ก ์ ์ ํ ๋๊ธฐํ์ ํ์ด์ผ. ๐ฅ
๐ฏ ๊ฐ๋น์ง ์ปฌ๋ ์ ํ๋
GC ํ๋์ ์ง์ง ๊ณ ๊ธ ์ฃผ์ ์ธ๋ฐ, ํ๋กํ์ผ๋ง ํด ์์ด๋ ๋ถ๊ฐ๋ฅํด. JProfiler๋ VisualVM์ผ๋ก GC ํจํด์ ๋ถ์ํ๊ณ ์ต์ ํํ ์ ์์ด.
๐ GC ์๊ณ ๋ฆฌ์ฆ ์ดํดํ๊ธฐ
์๋ฐ์๋ ์ฌ๋ฌ GC ์๊ณ ๋ฆฌ์ฆ์ด ์์ด:
์ฃผ์ GC ์๊ณ ๋ฆฌ์ฆ:
โข Serial GC: ์ฑ๊ธ ์ค๋ ๋๋ก ๋์. ์์ ์ ํ๋ฆฌ์ผ์ด์
์ฉ.
โข Parallel GC: ๋ฉํฐ ์ค๋ ๋๋ก ๋์. ์ฒ๋ฆฌ๋ ์ค์.
โข CMS GC: ์๋ต ์๊ฐ ์ค์. Stop-the-World ์๊ฐ ์ต์ํ.
โข G1 GC: Java 9๋ถํฐ ๊ธฐ๋ณธ. ํฐ ํ์ ์ ํฉ.
โข ZGC: Java 11+. ์ด์ ์ง์ฐ. ํ
๋ผ๋ฐ์ดํธ๊ธ ํ๋ OK.
VisualVM์ VisualGC ํ๋ฌ๊ทธ์ธ์ ์ค์นํ๋ฉด GC๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง ์ค์๊ฐ์ผ๋ก ๋ณผ ์ ์์ด. Eden ์์ญ์ด ์ฐจ๋ฉด Minor GC๊ฐ ์ผ์ด๋๊ณ , Old ์์ญ์ด ์ฐจ๋ฉด Major GC๊ฐ ์ผ์ด๋๋ ๊ฒ ๋์ผ๋ก ๋ณด์ฌ!
๐ง GC ํ๋ ์ค์
๋ด๊ฐ ์ค์ ๋ก ํ๋ GC ํ๋ ์ฌ๋ก๋ฅผ ๊ณต์ ํ ๊ฒ.
// ๋ฌธ์ ์ํฉ: Full GC๊ฐ ๋๋ฌด ์์ฃผ ๋ฐ์
// VisualVM์ผ๋ก ํ์ธํ ๊ฒฐ๊ณผ:
// - Minor GC: ํ๊ท 50ms, 10์ด๋ง๋ค ๋ฐ์
// - Full GC: ํ๊ท 2์ด, 5๋ถ๋ง๋ค ๋ฐ์
// - Old Generation์ด ๋น ๋ฅด๊ฒ ์ฐจ์ค๋ฆ
// ์์ธ ๋ถ์: ํฐ ๊ฐ์ฒด๋ค์ด ๋ฐ๋ก Old Generation์ผ๋ก ์ด๋
// Heap Dump๋ฅผ ๋ ์ ํ์ธํด๋ณด๋ ๋์ฉ๋ byte[] ๋ฐฐ์ด๋ค์ด ๋ฌธ์
// ๊ธฐ์กด JVM ์ต์
java -Xms512m -Xmx2g -jar app.jar
// ํ๋ ํ JVM ์ต์
java -Xms2g -Xmx4g \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:G1HeapRegionSize=16m \
-XX:InitiatingHeapOccupancyPercent=45 \
-jar app.jar
// ๊ฒฐ๊ณผ:
// - Minor GC: ํ๊ท 30ms, 20์ด๋ง๋ค ๋ฐ์
// - Full GC: ํ๊ท 500ms, 30๋ถ๋ง๋ค ๋ฐ์
// - ์ ์ฒด ์ฒ๋ฆฌ๋ 20% ํฅ์
๐ก GC ํ๋ ํ:
1. ํ ํฌ๊ธฐ ์ ์ ํ ์ค์ : ๋๋ฌด ์์ผ๋ฉด GC๊ฐ ์์ฃผ ์ผ์ด๋๊ณ , ๋๋ฌด ํฌ๋ฉด Full GC ์๊ฐ์ด ๊ธธ์ด์ ธ.
2. Young Generation ํฌ๊ธฐ ์กฐ์ : ๋๋ถ๋ถ์ ๊ฐ์ฒด๋ ๊ธ๋ฐฉ ์ฃฝ์ผ๋๊น Young์ ํฌ๊ฒ ํ๋ฉด Minor GC ๋น๋๊ฐ ์ค์ด๋ค์ด.
3. GC ๋ก๊ทธ ํ์ฑํ: -Xlog:gc* ์ต์
์ผ๋ก GC ๋ก๊ทธ๋ฅผ ๋จ๊ฒจ. ๋ถ์์ ํ์์ผ!
4. ์ ํ๋ฆฌ์ผ์ด์
ํน์ฑ ๊ณ ๋ ค: ์ฒ๋ฆฌ๋์ด ์ค์ํ๋ฉด Parallel GC, ์๋ต ์๊ฐ์ด ์ค์ํ๋ฉด G1์ด๋ ZGC.
๐ ํ๋ก๋์ ํ๊ฒฝ์์์ ํ๋กํ์ผ๋ง
๊ฐ๋ฐ ํ๊ฒฝ์์๋ ๋ง์๊ป ํ๋กํ์ผ๋งํด๋ ๋๋๋ฐ, ํ๋ก๋์ ์ ์กฐ์ฌํด์ผ ํด. ์ฌ์ฉ์๋ค์ด ์ฐ๊ณ ์๋ ์๋น์ค๋๊น! ๐ฐ
โ ๏ธ ํ๋ก๋์ ํ๋กํ์ผ๋ง ์ฃผ์์ฌํญ
์ ๋ ํ์ง ๋ง์์ผ ํ ๊ฒ:
โข Instrumentation ๋ฐฉ์์ ํ๋กํ์ผ๋ง (๋๋ฌด ๋๋ ค์ ธ)
โข ๋ชจ๋ ๋ฉ์๋ ์ถ์ (์ค๋ฒํค๋ ํญ๋ฐ)
โข ํผํฌ ํ์์ ํ๋กํ์ผ๋ง (์๋น์ค ์ฅ์ ์ํ)
โข ์ฅ์๊ฐ ํ๋กํ์ผ๋ง (๋์คํฌ ์ฉ๋ ๋ฌธ์ )
์์ ํ ํ๋ก๋์ ํ๋กํ์ผ๋ง:
โข ์ํ๋ง ๋ฐฉ์ ์ฌ์ฉ: ์ค๋ฒํค๋ 5% ์ดํ
โข ํน์ ํจํค์ง๋ง ํ๊ฒํ
: ์์ฌ๋๋ ๋ถ๋ถ๋ง ์ง์ค
โข ์งง์ ์๊ฐ๋ง ์คํ: 5~10๋ถ ์ ๋๋ฉด ์ถฉ๋ถ
โข ํ๊ฐํ ์๊ฐ๋ ์ ํ: ์๋ฒฝ์ด๋ ์ฃผ๋ง
โข ๋ชจ๋ํฐ๋ง ๋ณํ: CPU, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ฅ ์ฒดํฌ
๐ APM ๋๊ตฌ์์ ์กฐํฉ
ํ๋ก๋์ ์์๋ ํ๋กํ์ผ๋ง ํด๋ณด๋ค APM(Application Performance Monitoring) ๋๊ตฌ๊ฐ ๋ ์ ํฉํด. New Relic, Datadog, Pinpoint ๊ฐ์ ๊ฑฐ ๋ง์ด์ผ.
APM์ ํญ์ ์ผ๋๊ณ ์ธ ์ ์๋๋ก ์ค๋ฒํค๋๊ฐ ์ต์ํ๋์ด ์์ด. ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ๊ทธ๋ JProfiler๋ VisualVM์ผ๋ก ๊น์ด ํ๊ณ ๋๋ ๊ฑฐ์ง! ๐
๋ด๊ฐ ์ฐ๋ ๋ชจ๋ํฐ๋ง ์ ๋ต:
1. APM์ผ๋ก ์์ ๋ชจ๋ํฐ๋ง: ์ ์ฒด์ ์ธ ์ฑ๋ฅ ์ถ์ด ํ์
2. ์๋ฆผ ์ค์ : ์๋ต ์๊ฐ > 1์ด, ์๋ฌ์จ > 1% ๋ฑ
3. ๋ฌธ์ ๋ฐ๊ฒฌ ์ ํ๋กํ์ผ๋ง: ์คํ
์ด์ง ํ๊ฒฝ์์ ์ฌํ ํ ๋ถ์
4. ์ ๊ธฐ์ ์ธ ์ฑ๋ฅ ๋ฆฌ๋ทฐ: ์ฃผ 1ํ ์ฑ๋ฅ ์งํ ๊ฒํ
๐ป ์ค์ต: ๊ฐ๋จํ ์ฑ๋ฅ ํ ์คํธ ํ๋ก์ ํธ
์ด๋ก ๋ง ๋ณด๋ฉด ์ฌ๋ฏธ์์์? ์ง์ ํด๋ณผ ์ ์๋ ์์ ๋ฅผ ๋ง๋ค์ด๋ดค์ด. ์ด๊ฑธ ๋ฐ๋ผํ๋ฉด์ ํ๋กํ์ผ๋ง ํด์ ์ตํ๋ด! ๐
// PerformanceTestApp.java
public class PerformanceTestApp {
public static void main(String[] args) throws InterruptedException {
System.out.println("์ฑ๋ฅ ํ
์คํธ ์์!");
System.out.println("VisualVM์ด๋ JProfiler๋ฅผ ์ฐ๊ฒฐํ์ธ์.");
Thread.sleep(5000); // ํ๋กํ์ผ๋ฌ ์ฐ๊ฒฐ ๋๊ธฐ
PerformanceTestApp app = new PerformanceTestApp();
// ํ
์คํธ 1: CPU ์ง์ฝ์ ์์
System.out.println("\n=== CPU ํ
์คํธ ===");
app.cpuIntensiveTask();
// ํ
์คํธ 2: ๋ฉ๋ชจ๋ฆฌ ์ง์ฝ์ ์์
System.out.println("\n=== ๋ฉ๋ชจ๋ฆฌ ํ
์คํธ ===");
app.memoryIntensiveTask();
// ํ
์คํธ 3: ๋นํจ์จ์ ์ธ ๋ฌธ์์ด ์ฐ์ฐ
System.out.println("\n=== ๋ฌธ์์ด ํ
์คํธ ===");
app.inefficientStringOperation();
// ํ
์คํธ 4: ํจ์จ์ ์ธ ๋ฌธ์์ด ์ฐ์ฐ
System.out.println("\n=== ๊ฐ์ ๋ ๋ฌธ์์ด ํ
์คํธ ===");
app.efficientStringOperation();
System.out.println("\nํ
์คํธ ์๋ฃ! ํ๋กํ์ผ๋ฌ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ์ธ์.");
}
// CPU๋ฅผ ๋ง์ด ์ฐ๋ ์์
public void cpuIntensiveTask() {
long start = System.currentTimeMillis();
for (int i = 0; i < 10; i++) {
calculatePrimes(100000);
}
long end = System.currentTimeMillis();
System.out.println("์์ ์๊ฐ: " + (end - start) + "ms");
}
private void calculatePrimes(int max) {
for (int i = 2; i < max; i++) {
boolean isPrime = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
isPrime = false;
break;
}
}
}
}
// ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ง์ด ์ฐ๋ ์์
public void memoryIntensiveTask() {
long start = System.currentTimeMillis();
List<byte[]> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
byte[] data = new byte[1024 * 100]; // 100KB
list.add(data);
}
long end = System.currentTimeMillis();
System.out.println("์์ฑ๋ ๊ฐ์ฒด ์: " + list.size());
System.out.println("์์ ์๊ฐ: " + (end - start) + "ms");
// ๋ฉ๋ชจ๋ฆฌ ํด์
list.clear();
}
// ๋นํจ์จ์ ์ธ ๋ฌธ์์ด ์ฐ์ฐ
public void inefficientStringOperation() {
long start = System.currentTimeMillis();
String result = "";
for (int i = 0; i < 10000; i++) {
result += i + ","; // ๋งค๋ฒ ์ String ๊ฐ์ฒด ์์ฑ!
}
long end = System.currentTimeMillis();
System.out.println("๊ฒฐ๊ณผ ๊ธธ์ด: " + result.length());
System.out.println("์์ ์๊ฐ: " + (end - start) + "ms");
}
// ํจ์จ์ ์ธ ๋ฌธ์์ด ์ฐ์ฐ
public void efficientStringOperation() {
long start = System.currentTimeMillis();
StringBuilder result = new StringBuilder();
for (int i = 0; i < 10000; i++) {
result.append(i).append(",");
}
long end = System.currentTimeMillis();
System.out.println("๊ฒฐ๊ณผ ๊ธธ์ด: " + result.length());
System.out.println("์์ ์๊ฐ: " + (end - start) + "ms");
}
}
์ด ์ฝ๋๋ฅผ ์คํํ๊ณ VisualVM์ด๋ JProfiler๋ฅผ ์ฐ๊ฒฐํด๋ด. ๊ทธ๋ฌ๋ฉด:
ํ์ธํ ์ ์๋ ๊ฒ๋ค:
โข CPU ํ๋กํ์ผ๋ง: calculatePrimes() ๋ฉ์๋๊ฐ CPU๋ฅผ ๋ง์ด ์ฐ๋ ๊ฒ ๋ณด์ฌ
โข ๋ฉ๋ชจ๋ฆฌ ํ๋กํ์ผ๋ง: byte[] ๋ฐฐ์ด์ด ํ์ ์ฐจ์งํ๋ ๊ฒ ๋ณด์ฌ
โข ์ฑ๋ฅ ๋น๊ต: inefficientStringOperation()๊ณผ efficientStringOperation()์ ์ฐจ์ด๊ฐ ๋ช
ํํด
โข GC ํ๋: ๋ฉ๋ชจ๋ฆฌ ํ
์คํธ ํ GC๊ฐ ์ผ์ด๋๋ ๊ฒ ๋ณด์ฌ
๐ ํ๋กํ์ผ๋ง ๋ฒ ์คํธ ํ๋ํฐ์ค
์ง๊ธ๊น์ง ๋ฐฐ์ด ๊ฑธ ์ ๋ฆฌํด์ ์ค์ ์์ ๋ฐ๋ก ์ธ ์ ์๋ ํ๋ค์ ๋ชจ์๋ดค์ด! ๐
โ ํด์ผ ํ ๊ฒ๋ค
1. ์ธก์ ๊ฐ๋ฅํ ๋ชฉํ ์ค์
"๋น ๋ฅด๊ฒ ๋ง๋ค์"๊ฐ ์๋๋ผ "์๋ต ์๊ฐ์ 500ms ์ดํ๋ก ์ค์ด์" ๊ฐ์ ๊ตฌ์ฒด์ ์ธ ๋ชฉํ๋ฅผ ์ธ์.
2. ๋ฒ ์ด์ค๋ผ์ธ ์ธก์
์ต์ ํ ์ ์ ํ์ฌ ์ฑ๋ฅ์ ์ ํํ ์ธก์ ํด. ๊ทธ๋์ผ ๊ฐ์ ํจ๊ณผ๋ฅผ ์ ์ ์์ด.
3. ๋ณ๋ชฉ ์ง์ ์ง์ค ๊ณต๋ต
80/20 ๋ฒ์น! ์ ์ฒด ์๊ฐ์ 80%๋ฅผ ์ฐจ์งํ๋ 20%์ ์ฝ๋๋ฅผ ์ฐพ์์ ๊ฐ์ ํด.
4. ํ ๋ฒ์ ํ๋์ฉ ๋ณ๊ฒฝ
์ฌ๋ฌ ๊ฐ๋ฅผ ๋์์ ๋ฐ๊พธ๋ฉด ๋ญ๊ฐ ํจ๊ณผ๊ฐ ์์๋์ง ์ ์ ์์ด. ํ๋์ฉ ๋ฐ๊พธ๊ณ ์ธก์ ํด.
5. ์ค์ ํ๊ฒฝ๊ณผ ์ ์ฌํ๊ฒ ํ ์คํธ
๊ฐ๋ฐ PC์์ ๋น ๋ฅด๋ค๊ณ ํ๋ก๋์ ์์๋ ๋น ๋ฅธ ๊ฑด ์๋์ผ. ์ค์ ๋ฐ์ดํฐ, ์ค์ ๋ถํ๋ก ํ ์คํธํด.
โ ํ์ง ๋ง์์ผ ํ ๊ฒ๋ค
1. ์ถ์ธก์ผ๋ก ์ต์ ํํ์ง ๋ง
"์ด ๋ถ๋ถ์ด ๋๋ฆด ๊ฒ ๊ฐ์"๊ฐ ์๋๋ผ ํ๋กํ์ผ๋ฌ๋ก ํ์ธํด. ์์๊ณผ ๋ค๋ฅธ ๊ฒฝ์ฐ๊ฐ ๋ง์!
2. ๋ฏธ์ธ ์ต์ ํ์ ์ง์ฐฉํ์ง ๋ง
1ms๋ฅผ ์ค์ด๋ ค๊ณ ์ฝ๋๋ฅผ ๋ณต์กํ๊ฒ ๋ง๋ค์ง ๋ง. ๊ฐ๋ ์ฑ๋ ์ค์ํด!
3. ์บ์ฑ์ ๋จ๋ฐํ์ง ๋ง
์บ์๋ ๋ง๋ฅ์ด ์๋์ผ. ๋ฉ๋ชจ๋ฆฌ๋ ๋จน๊ณ , ๋๊ธฐํ ๋ฌธ์ ๋ ์๊ธธ ์ ์์ด.
4. ํ๋ก๋์ ์์ ๋ฌด๋ฆฌํ๊ฒ ํ๋กํ์ผ๋งํ์ง ๋ง
์ฌ์ฉ์ ๊ฒฝํ์ ํด์น๋ฉด์๊น์ง ํ๋กํ์ผ๋งํ ํ์๋ ์์ด. ์คํ ์ด์ง์์ ์ฌํํด.
๐ ์ฌ๋ฅ๋ท์์ ๋ ๋ฐฐ์ฐ๊ธฐ
ํ๋กํ์ผ๋ง๊ณผ ์ฑ๋ฅ ์ต์ ํ๋ ์ ๋ง ๊น์ ์ฃผ์ ์ผ. ์ด ๊ธ์์ ๊ธฐ๋ณธ์ ๋ค๋ค์ง๋ง, ์ค์ ์์๋ ๋ ๋ณต์กํ ๋ฌธ์ ๋ค์ด ๋ง์. ๐ค
๋ง์ฝ ๋ ๊น์ด ๋ฐฐ์ฐ๊ณ ์ถ๊ฑฐ๋, ์ค์ ํ๋ก์ ํธ์์ ์ฑ๋ฅ ๋ฌธ์ ๋ฅผ ๊ฒช๊ณ ์๋ค๋ฉด ์ฌ๋ฅ๋ท์ ํ์ฉํด๋ด! ์ฌ๋ฅ๋ท์๋ ์๋ฐ ์ฑ๋ฅ ์ต์ ํ ์ ๋ฌธ๊ฐ๋ค์ด ๋ง์ด ์์ด์, 1:1 ์ฝ์นญ์ด๋ ์ฝ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ์ ์ ์๊ฑฐ๋ . ๐ก
๋๋ ์ฒ์์ ํผ์ ์ฝ์งํ๋ฉด์ ๋ฐฐ์ ๋๋ฐ, ์ ๋ฌธ๊ฐํํ ๋ฐฐ์ ์ผ๋ฉด ํจ์ฌ ๋นจ๋ฆฌ ์ฑ์ฅํ์ ๊ฑฐ์ผ. ํนํ ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ์๋์ด ๊ฐ๋ฐ์๋ค์ ๋ ธํ์ฐ๋ ์ ๋ง ๊ฐ์ง ๊ฑฐ๊ฑฐ๋ !
๐ฅ ๊ณ ๊ธ ํ๋กํ์ผ๋ง ๊ธฐ๋ฒ
๊ธฐ๋ณธ์ ๋์ด์ ์ข ๋ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค๋ ์์๋ณผ๊น? ์ด๊ฑด ์ง์ง ์ค๋ ฅ์๋ค์ด ์ฐ๋ ํ ํฌ๋์ด์ผ! ๐
๐ฏ ํ๋ ์ ๊ทธ๋ํ(Flame Graph)
ํ๋ ์ ๊ทธ๋ํ๋ ํ๋กํ์ผ๋ง ๋ฐ์ดํฐ๋ฅผ ์๊ฐํํ๋ ์์ฃผ ๋ฉ์ง ๋ฐฉ๋ฒ์ด์ผ. ๋ง์น ๋ถ๊ฝ์ฒ๋ผ ์๊ฒผ๋ค๊ณ ํด์ ํ๋ ์ ๊ทธ๋ํ๋ผ๊ณ ๋ถ๋ฌ.
ํ๋ ์ ๊ทธ๋ํ์ ์ฅ์ :
โข ์ง๊ด์ : ํ๋์ ์ด๋๊ฐ ๋ฌธ์ ์ธ์ง ๋ณด์ฌ
โข ๊ณ์ธต ๊ตฌ์กฐ: ๋ฉ์๋ ํธ์ถ ์คํ์ ์๊ฐ์ ์ผ๋ก ํํ
โข ๋น์จ ํ์: ๋์ด๊ฐ ์คํ ์๊ฐ์ ๋น๋กํด
โข ์ธํฐ๋ํฐ๋ธ: ํด๋ฆญํด์ ํ๋/์ถ์ ๊ฐ๋ฅ
JProfiler์๋ ํ๋ ์ ๊ทธ๋ํ๊ฐ ๊ธฐ๋ณธ ๋ด์ฅ๋์ด ์๊ณ , VisualVM์ ํ๋ฌ๊ทธ์ธ์ผ๋ก ์ถ๊ฐํ ์ ์์ด. ํ ๋ฒ ์จ๋ณด๋ฉด ๋ค๋ฅธ ๋ทฐ๋ก๋ ๋ชป ๋์๊ฐ! ๐ฅ
๐งช A/B ํ ์คํธ๋ก ์ฑ๋ฅ ๋น๊ต
์ฝ๋๋ฅผ ๊ฐ์ ํ์ ๋ ์ ๋ง ๋นจ๋ผ์ก๋์ง ํ์ธํ๋ ค๋ฉด A/B ํ ์คํธ๊ฐ ์ต๊ณ ์ผ.
// ์ฑ๋ฅ ๋น๊ต ํ
์คํธ ํ๋ ์์ํฌ
public class PerformanceComparison {
public static void compare(String name, Runnable methodA, Runnable methodB) {
// ์๋ฐ์
(JIT ์ปดํ์ผ ๋๊ธฐ)
for (int i = 0; i < 1000; i++) {
methodA.run();
methodB.run();
}
// ์ค์ ์ธก์
long timeA = measureTime(methodA, 10000);
long timeB = measureTime(methodB, 10000);
System.out.println("=== " + name + " ===");
System.out.println("๋ฐฉ๋ฒ A: " + timeA + "ms");
System.out.println("๋ฐฉ๋ฒ B: " + timeB + "ms");
double improvement = ((double)(timeA - timeB) / timeA) * 100;
System.out.println("๊ฐ์ ์จ: " + String.format("%.2f", improvement) + "%");
}
private static long measureTime(Runnable method, int iterations) {
long start = System.nanoTime();
for (int i = 0; i < iterations; i++) {
method.run();
}
long end = System.nanoTime();
return (end - start) / 1_000_000; // ms๋ก ๋ณํ
}
public static void main(String[] args) {
// ์์ : String vs StringBuilder
compare("๋ฌธ์์ด ์ฐ๊ฒฐ",
() -> {
String s = "";
for (int i = 0; i < 100; i++) {
s += i;
}
},
() -> {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.append(i);
}
}
);
}
}
์ด๋ ๊ฒ ํ๋ฉด ๊ฐ๊ด์ ์ธ ์์น๋ก ์ฑ๋ฅ ๊ฐ์ ์ ์ฆ๋ช ํ ์ ์์ด! ๐
๐ช JMH๋ก ๋ง์ดํฌ๋ก๋ฒค์น๋งํน
JMH(Java Microbenchmark Harness)๋ ์ค๋ผํด์์ ๋ง๋ ๋ฒค์น๋งํน ํ๋ ์์ํฌ์ผ. ์ง์ง ์ ํํ ์ฑ๋ฅ ์ธก์ ์ ํ๊ณ ์ถ์ ๋ ์จ.
// Maven ์์กด์ฑ ์ถ๊ฐ
// pom.xml
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.36</version>
</dependency>
// JMH ๋ฒค์น๋งํฌ ์์
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class StringConcatBenchmark {
@Param({"10", "100", "1000"})
private int size;
@Benchmark
public String stringConcat() {
String result = "";
for (int i = 0; i < size; i++) {
result += i;
}
return result;
}
@Benchmark
public String stringBuilderConcat() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < size; i++) {
sb.append(i);
}
return sb.toString();
}
public static void main(String[] args) throws Exception {
org.openjdk.jmh.Main.main(args);
}
}
// ์คํ ๊ฒฐ๊ณผ ์์:
// Benchmark (size) Mode Cnt Score Error Units
// StringConcatBenchmark.stringConcat 10 avgt 25 245.123 ยฑ 3.456 ns/op
// StringConcatBenchmark.stringConcat 100 avgt 25 8234.567 ยฑ 45.678 ns/op
// StringConcatBenchmark.stringBuilderConcat 10 avgt 25 89.012 ยฑ 1.234 ns/op
// StringConcatBenchmark.stringBuilderConcat 100 avgt 25 456.789 ยฑ 5.678 ns/op
JMH๋ JIT ์ปดํ์ผ, ๊ฐ๋น์ง ์ปฌ๋ ์ , CPU ์บ์ ๊ฐ์ ์์๋ค์ ๋ค ๊ณ ๋ คํด์ ์ ํํ๊ฒ ์ธก์ ํด์ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์๋ค์ด ๋ง์ด ์จ! ๐ฏ
๐ก๏ธ ๋ฉ๋ชจ๋ฆฌ ๋์ ์๋ฒฝ ๊ฐ์ด๋
๋ฉ๋ชจ๋ฆฌ ๋์๋ ์๋ฐ ๊ฐ๋ฐ์์ ์์ํ ์์ ์ผ. ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ์์ด๋ ๋ฉ๋ชจ๋ฆฌ ๋์๋ ๋ฐ์ํ ์ ์๊ฑฐ๋ ! ๐ฑ
๐ ๋ฉ๋ชจ๋ฆฌ ๋์์ ์ฃผ์ ์์ธ๋ค
1. Static ์ปฌ๋ ์ ์ ๊ณ์ ์ถ๊ฐ
// ๋์ ์
public class UserCache {
private static Map<Long, User> cache = new HashMap<>();
public static void addUser(User user) {
cache.put(user.getId(), user);
// ์ ๊ฑฐํ๋ ๋ก์ง์ด ์์ผ๋ฉด ๊ณ์ ์์ฌ!
}
}
// ์ข์ ์
public class UserCache {
private static Map<Long, User> cache = new WeakHashMap<>();
// ๋๋
private static Cache<Long, User> cache = CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();
}
2. ๋ฆฌ์ค๋๋ ์ฝ๋ฐฑ ๋ฑ๋ก ํ ๋ฏธํด์
// ๋์ ์
public class EventManager {
private List<EventListener> listeners = new ArrayList<>();
public void addListener(EventListener listener) {
listeners.add(listener);
// ์ ๊ฑฐ ๋ฉ์๋๊ฐ ์์ผ๋ฉด ๊ณ์ ์ฐธ์กฐ๋ฅผ ์ ์ง!
}
}
// ์ข์ ์
public class EventManager {
private List<WeakReference<EventListener>> listeners = new ArrayList<>();
public void addListener(EventListener listener) {
listeners.add(new WeakReference<>(listener));
}
public void removeListener(EventListener listener) {
listeners.removeIf(ref -> {
EventListener l = ref.get();
return l == null || l == listener;
});
}
}
3. ThreadLocal ๋ฏธ์ ๋ฆฌ
// ๋์ ์
public class UserContext {
private static ThreadLocal<User> currentUser = new ThreadLocal<>();
public static void setUser(User user) {
currentUser.set(user);
// ์ค๋ ๋ํ ํ๊ฒฝ์์ remove()๋ฅผ ์ ํ๋ฉด ๋์!
}
}
// ์ข์ ์
public class UserContext {
private static ThreadLocal<User> currentUser = new ThreadLocal<>();
public static void setUser(User user) {
currentUser.set(user);
}
public static void clear() {
currentUser.remove(); // ๋ฐ๋์ ์ ๋ฆฌ!
}
}
// ์ฌ์ฉ ์
try {
UserContext.setUser(user);
// ๋น์ฆ๋์ค ๋ก์ง
} finally {
UserContext.clear(); // ํญ์ ์ ๋ฆฌ
}
๐ง ๋ฉ๋ชจ๋ฆฌ ๋์ ์ฐพ๋ ๋ฐฉ๋ฒ
Step 1: ํ ๋คํ ์์ฑ
// ๋ฐฉ๋ฒ 1: jmap ๋ช
๋ น์ด ์ฌ์ฉ
jmap -dump:live,format=b,file=heap.bin [PID]
// ๋ฐฉ๋ฒ 2: JVM ์ต์
์ผ๋ก ์๋ ์์ฑ
java -XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/tmp/heapdump.hprof \
-jar app.jar
// ๋ฐฉ๋ฒ 3: VisualVM์์ "Heap Dump" ๋ฒํผ ํด๋ฆญ
Step 2: ํ ๋คํ ๋ถ์
JProfiler๋ Eclipse MAT(Memory Analyzer Tool)๋ก ํ ๋คํ๋ฅผ ์ด์ด๋ด. ๊ทธ๋ฌ๋ฉด:
ํ์ธํ ํฌ์ธํธ:
โข Dominator Tree: ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ง์ด ์ฐจ์งํ๋ ๊ฐ์ฒด ์์
โข Leak Suspects: ๋ฉ๋ชจ๋ฆฌ ๋์ ์์ฌ ๊ฐ์ฒด ์๋ ํ์ง
โข Path to GC Roots: ์ GC๊ฐ ํ์ํ์ง ๋ชปํ๋์ง ๊ฒฝ๋ก ์ถ์
โข Duplicate Classes: ๊ฐ์ ํด๋์ค๊ฐ ์ฌ๋ฌ ํด๋์ค๋ก๋์ ๋ก๋๋๋์ง
Step 3: ์๊ฐ์ ๋ฐ๋ฅธ ๋ณํ ์ถ์
ํ ๋ฒ์ ํ ๋คํ๋ก๋ ๋ถ์กฑํ ์ ์์ด. ์๊ฐ ๊ฐ๊ฒฉ์ ๋๊ณ ์ฌ๋ฌ ๋ฒ ๋ ์ ๋น๊ตํด๋ด.
// 10๋ถ ๊ฐ๊ฒฉ์ผ๋ก 3๋ฒ ํ ๋คํ
jmap -dump:live,format=b,file=heap1.bin [PID]
# 10๋ถ ๋๊ธฐ
jmap -dump:live,format=b,file=heap2.bin [PID]
# 10๋ถ ๋๊ธฐ
jmap -dump:live,format=b,file=heap3.bin [PID]
// JProfiler์์ 3๊ฐ ํ์ผ์ ๋น๊ตํ๋ฉด
// ๊ณ์ ์ฆ๊ฐํ๋ ๊ฐ์ฒด๋ฅผ ์ฐพ์ ์ ์์ด!
โ๏ธ JVM ํ๋ ์ค์ ๊ฐ์ด๋
JVM ์ต์ ์ ์ง์ง ๋ง์. ๊ทผ๋ฐ ๋ค ์ ํ์๋ ์๊ณ , ์์ฃผ ์ฐ๋ ๊ฒ๋ค๋ง ์๋ฉด ๋ผ! ๐ช
๐๏ธ ํ์ JVM ์ต์ ๋ค
// ๊ธฐ๋ณธ ํ ์ค์
-Xms2g # ์ด๊ธฐ ํ ํฌ๊ธฐ (2GB)
-Xmx4g # ์ต๋ ํ ํฌ๊ธฐ (4GB)
-Xmn1g # Young Generation ํฌ๊ธฐ (1GB)
// GC ์๊ณ ๋ฆฌ์ฆ ์ ํ
-XX:+UseG1GC # G1 GC ์ฌ์ฉ (Java 9+ ๊ธฐ๋ณธ)
-XX:+UseParallelGC # Parallel GC ์ฌ์ฉ
-XX:+UseConcMarkSweepGC # CMS GC ์ฌ์ฉ (deprecated)
-XX:+UseZGC # ZGC ์ฌ์ฉ (Java 11+)
// GC ๋ก๊น
-Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=100m
// ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ
-XX:MetaspaceSize=256m # Metaspace ์ด๊ธฐ ํฌ๊ธฐ
-XX:MaxMetaspaceSize=512m # Metaspace ์ต๋ ํฌ๊ธฐ
-XX:MaxDirectMemorySize=1g # Direct Memory ์ต๋ ํฌ๊ธฐ
// ์ฑ๋ฅ ํ๋
-XX:+UseStringDeduplication # ์ค๋ณต ๋ฌธ์์ด ์ ๊ฑฐ (G1 GC)
-XX:+UseCompressedOops # ๊ฐ์ฒด ํฌ์ธํฐ ์์ถ (ํ < 32GB)
-XX:+TieredCompilation # ๊ณ์ธต์ ์ปดํ์ผ (๊ธฐ๋ณธ ํ์ฑํ)
// ๋๋ฒ๊น
-XX:+HeapDumpOnOutOfMemoryError # OOM ์ ํ ๋คํ
-XX:HeapDumpPath=/tmp # ํ ๋คํ ์ ์ฅ ๊ฒฝ๋ก
-XX:+PrintGCDetails # GC ์์ธ ์ ๋ณด ์ถ๋ ฅ
๐ฏ ์ํฉ๋ณ JVM ์ค์ ์์
1. ์น ์ ํ๋ฆฌ์ผ์ด์ (์๋ต ์๊ฐ ์ค์)
java -Xms4g -Xmx4g \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:ParallelGCThreads=8 \
-XX:ConcGCThreads=2 \
-XX:InitiatingHeapOccupancyPercent=45 \
-Xlog:gc*:file=gc.log:time \
-XX:+HeapDumpOnOutOfMemoryError \
-jar webapp.jar
2. ๋ฐฐ์น ํ๋ก์ธ์ฑ (์ฒ๋ฆฌ๋ ์ค์)
java -Xms8g -Xmx8g \
-XX:+UseParallelGC \
-XX:ParallelGCThreads=16 \
-XX:+UseAdaptiveSizePolicy \
-Xlog:gc*:file=gc.log:time \
-jar batch-processor.jar
3. ๋ง์ดํฌ๋ก์๋น์ค (์์ ํ, ๋น ๋ฅธ ์์)
java -Xms256m -Xmx512m \
-XX:+UseSerialGC \
-XX:TieredStopAtLevel=1 \
-Xshare:on \
-jar microservice.jar
4. ๋์ฉ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ (ํฐ ํ)
java -Xms32g -Xmx32g \
-XX:+UseZGC \
-XX:ConcGCThreads=4 \
-XX:ZCollectionInterval=120 \
-Xlog:gc*:file=gc.log:time \
-jar big-data-processor.jar
๐ ์ค์ ํธ๋ฌ๋ธ์ํ ์ฌ๋ก์ง
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ์ฌ๋ก๋ค์ ๋ณด์! ๋ด๊ฐ ์ง์ ๊ฒช์๊ฑฐ๋ ํด๊ฒฐํ ๋ฌธ์ ๋ค์ด์ผ. ๐
๐ ์ฌ๋ก 1: ๊ฐ์๊ธฐ ๋๋ ค์ง๋ API
์ฆ์: ํ์์๋ ๊ด์ฐฎ์๋ฐ ๊ฐ๋ API ์๋ต์ด 10์ด ์ด์ ๊ฑธ๋ฆผ
๋ถ์ ๊ณผ์ :
1. VisualVM์ผ๋ก CPU ํ๋กํ์ผ๋ง โ ํน์ ๋ฉ์๋์์ ์๊ฐ ์์
2. ํด๋น ๋ฉ์๋ ํ์ธ โ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฟผ๋ฆฌ
3. ์ฟผ๋ฆฌ ๋ก๊ทธ ํ์ธ โ Full Table Scan ๋ฐ์
4. ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ์ธ โ ์ธ๋ฑ์ค ๋๋ฝ!
ํด๊ฒฐ์ฑ :
-- ๋ฌธ์ ์ ์ฟผ๋ฆฌ
SELECT * FROM orders
WHERE customer_id = ?
AND order_date > ?;
-- ์ธ๋ฑ์ค ์ถ๊ฐ
CREATE INDEX idx_orders_customer_date
ON orders(customer_id, order_date);
-- ๊ฒฐ๊ณผ: 10์ด โ 50ms
๊ตํ: ํ๋กํ์ผ๋ง์ ์ฝ๋๋ง ๋ณด๋ ๊ฒ ์๋์ผ. ๋ฐ์ดํฐ๋ฒ ์ด์ค, ๋คํธ์ํฌ, ์ธ๋ถ API ๋ฑ ์ ์ฒด ์คํ์ ๋ด์ผ ํด! ๐
๐ ์ฌ๋ก 2: ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ์ ์ฆ๊ฐ
์ฆ์: ์ ํ๋ฆฌ์ผ์ด์ ์ ์์ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ์ ์ฌ๋ผ๊ฐ๋ค๊ฐ ๊ฒฐ๊ตญ OOM
๋ถ์ ๊ณผ์ :
1. VisualVM Monitor ํญ โ ํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ์ ์ฆ๊ฐ
2. Perform GC ๋ฒํผ ํด๋ฆญ โ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ์ค์ด๋ฆ
3. Heap Dump ์์ฑ โ JProfiler๋ก ๋ถ์
4. Biggest Objects โ HashMap์ด 2GB ์ฐจ์ง
5. Path to GC Roots โ CacheManager์ static ํ๋
ํด๊ฒฐ์ฑ :
// ๋ฌธ์ ์ฝ๋
public class CacheManager {
private static Map<String, byte[]> cache = new HashMap<>();
public static void cache(String key, byte[] data) {
cache.put(key, data); // ๋ฌดํ์ ์ฆ๊ฐ!
}
}
// ํด๊ฒฐ ์ฝ๋
public class CacheManager {
private static Cache<String, byte[]> cache = CacheBuilder.newBuilder()
.maximumSize(1000) // ์ต๋ 1000๊ฐ
.expireAfterWrite(1, TimeUnit.HOURS) // 1์๊ฐ ํ ๋ง๋ฃ
.build();
public static void cache(String key, byte[] data) {
cache.put(key, data);
}
}
๊ตํ: ์บ์๋ ๋ฐ๋์ ํฌ๊ธฐ ์ ํ๊ณผ ๋ง๋ฃ ์ ์ฑ ์ ์ค์ ํด์ผ ํด! ๐ฏ
๐ ์ฌ๋ก 3: CPU ์ฌ์ฉ๋ฅ 100%
์ฆ์: ์๋ฒ CPU๊ฐ 100%์ ๋๋ฌํ๊ณ ์๋ต์ด ์์
๋ถ์ ๊ณผ์ :
1. top ๋ช
๋ น์ด๋ก ํ์ธ โ ์๋ฐ ํ๋ก์ธ์ค๊ฐ CPU ๋
์
2. jstack์ผ๋ก ์ค๋ ๋ ๋คํ โ ํน์ ์ค๋ ๋๊ฐ RUNNABLE ์ํ
3. JProfiler๋ก CPU ํ๋กํ์ผ๋ง โ ๋ฌดํ ๋ฃจํ ๋ฐ๊ฒฌ
ํด๊ฒฐ์ฑ :
// ๋ฌธ์ ์ฝ๋
public void processQueue() {
while (true) {
Task task = queue.poll();
if (task != null) {
task.execute();
}
// ํ๊ฐ ๋น์ด์์ด๋ ๊ณ์ ํด๋ง! CPU 100%
}
}
// ํด๊ฒฐ ์ฝ๋
public void processQueue() {
while (true) {
try {
Task task = queue.poll(1, TimeUnit.SECONDS); // ํ์์์ ์ค์
if (task != null) {
task.execute();
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
๊ตํ: ๋ฌดํ ๋ฃจํ์๋ ๋ฐ๋์ ๋๊ธฐ ์๊ฐ์ ๋ฃ์ด์ผ ํด! โฐ
๐ ์ฑ๋ฅ ์ต์ ํ ์ฒดํฌ๋ฆฌ์คํธ
๋ง์ง๋ง์ผ๋ก ์ค์ ์์ ๋ฐ๋ก ์ธ ์ ์๋ ์ฒดํฌ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด๋ดค์ด. ํ๋ก์ ํธํ ๋ ์ด๊ฑฐ ๋ณด๋ฉด์ ์ฒดํฌํด๋ด! โ
๐ ์ฝ๋ ๋ ๋ฒจ ์ต์ ํ
โ ๋ถํ์ํ ๊ฐ์ฒด ์์ฑ ์ ๊ฑฐ (ํนํ ๋ฃจํ ์)
โ StringBuilder ์ฌ์ฉ (๋ฌธ์์ด ์ฐ๊ฒฐ์ด ๋ง์ ๋)
โ ์ปฌ๋ ์
์ด๊ธฐ ์ฉ๋ ์ค์ (ArrayList, HashMap ๋ฑ)
โ Stream API ์ ์ ํ ์ฌ์ฉ (๋๋ฌด ๋ณต์กํ๋ฉด for๋ฌธ์ด ๋ ๋น ๋ฅผ ์ ์์)
โ ๋ถํ์ํ ๋๊ธฐํ ์ ๊ฑฐ
โ ์ง์ฐ ์ด๊ธฐํ ๊ณ ๋ ค (Lazy Initialization)
โ ์บ์ฑ ์ ์ฉ (์์ฃผ ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ)
โ ๋ถ๋ณ ๊ฐ์ฒด ํ์ฉ (์ค๋ ๋ ์์ ์ฑ + ์ฑ๋ฅ)
๐ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ต์ ํ
โ N+1 ์ฟผ๋ฆฌ ๋ฌธ์ ํด๊ฒฐ (Fetch Join, Batch Size)
โ ์ ์ ํ ์ธ๋ฑ์ค ์์ฑ
โ ์ฟผ๋ฆฌ ์ต์ ํ (๋ถํ์ํ ์ปฌ๋ผ ์กฐํ ์ ๊ฑฐ)
โ ์ปค๋ฅ์
ํ ์ค์ ์ต์ ํ
โ ํธ๋์ญ์
๋ฒ์ ์ต์ํ
โ ์ฝ๊ธฐ ์ ์ฉ ํธ๋์ญ์
ํ์ฉ (@Transactional(readOnly=true))
โ ๋ฐฐ์น ์ฒ๋ฆฌ ํ์ฉ (๋๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์)
๐ JVM ์ต์ ํ
โ ์ ์ ํ ํ ํฌ๊ธฐ ์ค์
โ GC ์๊ณ ๋ฆฌ์ฆ ์ ํ
โ GC ๋ก๊ทธ ํ์ฑํ ๋ฐ ๋ชจ๋ํฐ๋ง
โ ๋ฉํ์คํ์ด์ค ํฌ๊ธฐ ์ค์
โ JIT ์ปดํ์ผ๋ฌ ์ค์
โ ํ๋กํ์ผ๋ง ๋๊ตฌ ํ์ฉ
๐ ์ํคํ ์ฒ ๋ ๋ฒจ ์ต์ ํ
โ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋์
(CompletableFuture, @Async)
โ ์บ์ ๋ ์ด์ด ์ถ๊ฐ (Redis, Memcached)
โ CDN ํ์ฉ (์ ์ ๋ฆฌ์์ค)
โ ๋ก๋ ๋ฐธ๋ฐ์ฑ
โ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฝ๊ธฐ ๋ณต์ ๋ณธ ํ์ฉ
โ ๋ฉ์์ง ํ ๋์
(๋น๋๊ธฐ ์ฒ๋ฆฌ)
โ ๋ง์ดํฌ๋ก์๋น์ค ๋ถ๋ฆฌ (๋ณ๋ชฉ ์ง์ )
๐ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด ์ง์ง ๋๋จํด! ๐ ํ๋กํ์ผ๋ง๊ณผ ์ฑ๋ฅ ์ต์ ํ๋ ์ ๋ง ๊น์ ์ฃผ์ ๋ผ์ ํ ๋ฒ์ ๋ค ์ดํดํ๊ธฐ ์ด๋ ค์ธ ์ ์์ด. ๊ทธ๋๋ ๊ด์ฐฎ์, ์ฒ์ฒํ ํ๋์ฉ ์ ์ฉํด๋ณด๋ฉด ๋ผ!
๋ด๊ฐ ์ฒ์ ํ๋กํ์ผ๋ง์ ๋ฐฐ์ธ ๋๋ ์ ๋ง ๋ง๋งํ์ด. "์ด๊ฑธ ์ด๋์๋ถํฐ ์์ํด์ผ ํ์ง?" ํ๊ณ ๋ง์ด์ผ. ๊ทผ๋ฐ ํ๋์ฉ ํด๋ณด๋๊น ์ ์ ์ฌ๋ฏธ์๋๋ผ๊ณ . ๋๋ฆฐ ์ฝ๋๋ฅผ ๋น ๋ฅด๊ฒ ๋ง๋๋ ๊ฑด ์ ๋ง ์ง๋ฆฟํ ๊ฒฝํ์ด์ผ! โก
๐ก ์ด๋ณด์๋ฅผ ์ํ ํ์ต ๋ก๋๋งต:
1์ฃผ์ฐจ: VisualVM ์ค์นํ๊ณ ๊ฐ๋จํ ์ ํ๋ฆฌ์ผ์ด์
๋ชจ๋ํฐ๋ง
2์ฃผ์ฐจ: CPU ํ๋กํ์ผ๋ง์ผ๋ก ๋๋ฆฐ ๋ฉ์๋ ์ฐพ๊ธฐ
3์ฃผ์ฐจ: ๋ฉ๋ชจ๋ฆฌ ํ๋กํ์ผ๋ง์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํจํด ๋ถ์
4์ฃผ์ฐจ: ์ค์ ํ๋ก์ ํธ์ ์ ์ฉํด๋ณด๊ธฐ
5์ฃผ์ฐจ: JProfiler ๊ฐ์ ๊ณ ๊ธ ๋๊ตฌ ์๋
6์ฃผ์ฐจ: GC ๋ก๊ทธ ๋ถ์ ๋ฐ ํ๋
๊ทธ๋ฆฌ๊ณ ํผ์ ํ๊ธฐ ์ด๋ ต๋ค๋ฉด ์ฌ๋ฅ๋ท์์ ๋ฉํ ๋ฅผ ์ฐพ์๋ด. ๊ฒฝํ ๋ง์ ๊ฐ๋ฐ์ํํ ๋ฐฐ์ฐ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์์ด. ๋๋ ์ฒ์์ ์ํ์ฐฉ์ค๊ฐ ๋ง์๋๋ฐ, ์ ๋ฐฐ ๊ฐ๋ฐ์๋คํํ ๋ฐฐ์ฐ๋ฉด์ ๋ง์ด ์ฑ์ฅํ๊ฑฐ๋ ! ๐
์ฑ๋ฅ ์ต์ ํ๋ ๋์ด ์๋ ์ฌ์ ์ด์ผ. ํญ์ ๋ ๋น ๋ฅด๊ฒ, ๋ ํจ์จ์ ์ผ๋ก ๋ง๋ค ๋ฐฉ๋ฒ์ด ์๊ฑฐ๋ . ํ์ง๋ง ๊ทธ๊ฒ ๋ฐ๋ก ๊ฐ๋ฐ์ ์ฌ๋ฏธ ์๋๊ฒ ์ด? ๐
์, ์ด์ ๋น์ ์ฐจ๋ก์ผ! ํ๋กํ์ผ๋ง ํด์ ์ด๊ณ , ๋น์ ์ ์ฝ๋๋ฅผ ๋ถ์ํด๋ด. ์ด๋ค ๋๋ผ์ด ๋ฐ๊ฒฌ์ ํ๊ฒ ๋ ์ง ๊ธฐ๋๋ผ! ํ์ดํ ! ๐ช๐ฅ
๐ฏ ํต์ฌ ์์ฝ
ํ๋กํ์ผ๋ง์ ์ถ์ธก์ด ์๋ ์ธก์ ์ผ๋ก ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๊ณผ์ ์
๋๋ค.
JProfiler์ VisualVM ๊ฐ์ ๋๊ตฌ๋ฅผ ํ์ฉํ๋ฉด ๋ณ๋ชฉ ์ง์ ์ ์ ํํ ์ฐพ์ ์ ์์ต๋๋ค.
์์ ์ต์ ํ๋ถํฐ ์์ํด์ ์ ์ง์ ์ผ๋ก ๊ฐ์ ํด๋๊ฐ์ธ์!
์ธก์ โ ๋ถ์ โ ์ต์ ํ โ ๊ฒ์ฆ์ ์ฌ์ดํด์ ๋ฐ๋ณตํ๋ฉด ๋ฉ๋๋ค! ๐ช
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.