Ver3.0 ๐ ์๋ฐ ์ฑ๋ฅ ๋ฒค์น๋งํน๊ณผ JMH๋ฅผ ํ์ฉํ ๋ง์ดํฌ๋ก ๋ฒค์น๋งํน ์๋ฒฝ ๊ฐ์ด๋

๐ ์๋ฐ ์ฑ๋ฅ ๋ฒค์น๋งํน๊ณผ JMH๋ฅผ ํ์ฉํ ๋ง์ดํฌ๋ก ๋ฒค์น๋งํน ์๋ฒฝ ๊ฐ์ด๋
์ฝ๋ ์ฑ๋ฅ์ ์ ํํ๊ฒ ์ธก์ ํ๊ณ ์ต์ ํํ๋ ๊ณผํ์ ์ ๊ทผ๋ฒ
๐ฏ ์ ์ฑ๋ฅ ๋ฒค์น๋งํน์ด ์ค์ํ ๊น?
์, ์น๊ตฌ์ผ! ํน์ ์ด๋ฐ ๊ฒฝํ ์์ด? ์ฝ๋๋ฅผ ์์ฑํ๊ณ ๋์ "์ด ๋ฐฉ๋ฒ์ด ๋ ๋น ๋ฅผ๊น, ์ ๋ฐฉ๋ฒ์ด ๋ ๋น ๋ฅผ๊น?" ํ๊ณ ๊ณ ๋ฏผํ ์ ๋ง์ด์ผ. ๐
์๋ฅผ ๋ค์ด StringBuilder vs StringBuffer, ArrayList vs LinkedList, ๋๋ Stream API vs ์ ํต์ ์ธ for๋ฌธ ์ค ์ด๋ค ๊ฒ ๋ ๋น ๋ฅธ์ง ๊ถ๊ธํ๋ ์๊ฐ๋ค ์์์?
๊ทธ๋ด ๋ ๋๋ถ๋ถ ๊ฐ๋ฐ์๋ค์ "์... ๊ทธ๋ฅ ๋๋์ ์ด๊ฒ ๋ ๋น ๋ฅผ ๊ฒ ๊ฐ์๋ฐ?"๋ผ๊ณ ์ถ์ธกํ๊ฑฐ๋, ๊ฐ๋จํ๊ฒ System.currentTimeMillis()๋ก ์๊ฐ์ ์ฌ๋ณด๊ณค ํด. ํ์ง๋ง ์ด๋ฐ ๋ฐฉ์์ ์ ๋ง ์ํํด! ๐จ
2. ๊ฐ๋น์ง ์ปฌ๋ ์ ์ํฅ: ์ธก์ ์ค๊ฐ์ GC๊ฐ ๋ฐ์ํ๋ฉด ๊ฒฐ๊ณผ๊ฐ ์๊ณก๋ผ.
3. JIT ์ปดํ์ผ๋ฌ ์ต์ ํ: ์ปดํ์ผ๋ฌ๊ฐ "์ด ์ฝ๋ ์ ์ฐ๋ค?"ํ๊ณ ์์ ์ ๊ฑฐํด๋ฒ๋ฆด ์๋ ์์ด.
4. ์บ์ ํจ๊ณผ: CPU ์บ์, ๋ฉ๋ชจ๋ฆฌ ์บ์ ๋ฑ์ด ๊ฒฐ๊ณผ์ ํฐ ์ํฅ์ ๋ฏธ์ณ.
5. ํต๊ณ์ ์ ๋ขฐ์ฑ ๋ถ์กฑ: ํ๋ ๋ฒ ์ธก์ ์ผ๋ก๋ ์ ํํ ๊ฒฐ๋ก ์ ๋ด๋ฆด ์ ์์ด.
์ด๋ฐ ๋ฌธ์ ๋ค ๋๋ฌธ์ ๊ณผํ์ ์ด๊ณ ์ ํํ ๋ฒค์น๋งํน ๋๊ตฌ๊ฐ ํ์ํ ๊ฑฐ์ผ. ๊ทธ๊ฒ ๋ฐ๋ก ์ค๋ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ธ JMH(Java Microbenchmark Harness)์ผ! ๐
๐ฌ JMH๋ ๋ฌด์์ธ๊ฐ?
JMH(Java Microbenchmark Harness)๋ OpenJDK ํ์ด ๊ฐ๋ฐํ ์๋ฐ ๋ง์ดํฌ๋ก ๋ฒค์น๋งํน ํ๋ ์์ํฌ์ผ. 2013๋
์ ์ฒ์ ๊ณต๊ฐ๋์๊ณ , ํ์ฌ๋ ์๋ฐ ์ฑ๋ฅ ์ธก์ ์ ์ฌ์ค์ ํ์ค(de facto standard)์ผ๋ก ์๋ฆฌ์ก์์ด. ๐ช
"๋ง์ดํฌ๋ก ๋ฒค์น๋งํน"์ด๋ผ๋ ๋ง์ด ์ข ์ด๋ ต๊ฒ ๋ค๋ฆด ์ ์๋๋ฐ, ์ฝ๊ฒ ๋งํ๋ฉด ์์ฃผ ์์ ์ฝ๋ ๋จ์์ ์ฑ๋ฅ์ ์ ๋ฐํ๊ฒ ์ธก์ ํ๋ ๊ฒ์ ์๋ฏธํด. ๋ฉ์๋ ํ๋, ์๊ณ ๋ฆฌ์ฆ ํ๋, ์ฌ์ง์ด ์ฝ๋ ๋ช ์ค์ ์ฑ๋ฅ๊น์ง ๋๋
ธ์ด(nanosecond) ๋จ์๋ก ์ธก์ ํ ์ ์์ง!
| ํน์ง | ์ค๋ช | ์ฅ์ |
|---|---|---|
| JVM ์๋ฐ์ | ์ฝ๋๋ฅผ ์ฌ๋ฌ ๋ฒ ์คํํ์ฌ JIT ์ปดํ์ผ๋ฌ๊ฐ ์ต์ ํํ๋๋ก ํจ | ์ค์ ์ด์ ํ๊ฒฝ๊ณผ ์ ์ฌํ ์กฐ๊ฑด์์ ์ธก์ |
| Dead Code ์ ๊ฑฐ ๋ฐฉ์ง | ์ปดํ์ผ๋ฌ๊ฐ ์ฌ์ฉํ์ง ์๋ ์ฝ๋๋ฅผ ์ ๊ฑฐํ์ง ๋ชปํ๋๋ก ๋ณดํธ | ์ธก์ ํ๋ ค๋ ์ฝ๋๊ฐ ์ค์ ๋ก ์คํ๋จ์ ๋ณด์ฅ |
| ํต๊ณ ๋ถ์ | ํ๊ท , ํ์คํธ์ฐจ, ๋ฐฑ๋ถ์์ ๋ฑ ๋ค์ํ ํต๊ณ ์ ๊ณต | ๊ฒฐ๊ณผ์ ์ ๋ขฐ์ฑ๊ณผ ์์ ์ฑ ํ์ธ ๊ฐ๋ฅ |
| ๋ค์ํ ์ธก์ ๋ชจ๋ | ์ฒ๋ฆฌ๋, ํ๊ท ์๊ฐ, ์ํ๋ง ๋ฑ ์ฌ๋ฌ ๋ฐฉ์ ์ง์ | ๋ชฉ์ ์ ๋ง๋ ์ธก์ ๋ฐฉ๋ฒ ์ ํ ๊ฐ๋ฅ |
| ๋ฉํฐ์ค๋ ๋ ์ง์ | ๋์์ฑ ํ๊ฒฝ์์์ ์ฑ๋ฅ ์ธก์ ๊ฐ๋ฅ | ์ค์ ์๋น์ค ํ๊ฒฝ ์๋ฎฌ๋ ์ด์ |
๐ ๏ธ JMH ์์ํ๊ธฐ: ํ๊ฒฝ ์ค์
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก JMH๋ฅผ ์ฌ์ฉํด๋ณด์! ์ค์ ์ ์๊ฐ๋ณด๋ค ๊ฐ๋จํด. ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ด. ๐
๊ธฐ์กด Maven ํ๋ก์ ํธ๊ฐ ์๋ค๋ฉด pom.xml์ ๋ค์ ์์กด์ฑ์ ์ถ๊ฐํ๋ฉด ๋ผ:
<dependencies>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.37</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>1.37</version>
<scope>provided</scope>
</dependency>
</dependencies>
์ฒ์ ์์ํ๋ค๋ฉด ์ด ๋ฐฉ๋ฒ์ด ํจ์ฌ ํธํด. JMH๊ฐ ์ ๊ณตํ๋ Maven Archetype์ ์ฌ์ฉํ๋ฉด ํ์ํ ๋ชจ๋ ์ค์ ์ด ์๋์ผ๋ก ์๋ฃ๋ผ:
mvn archetype:generate \
-DinteractiveMode=false \
-DarchetypeGroupId=org.openjdk.jmh \
-DarchetypeArtifactId=jmh-java-benchmark-archetype \
-DgroupId=com.mycompany \
-DartifactId=my-benchmark \
-Dversion=1.0
์ด ๋ช ๋ น์ด๋ฅผ ์คํํ๋ฉด my-benchmark๋ผ๋ ํด๋๊ฐ ์์ฑ๋๊ณ , ๊ทธ ์์ ์ํ ๋ฒค์น๋งํฌ ์ฝ๋์ ํจ๊ป ์๋ฒฝํ๊ฒ ์ค์ ๋ ํ๋ก์ ํธ๊ฐ ๋ง๋ค์ด์ ธ! ๐
Gradle์ ์ ํธํ๋ค๋ฉด build.gradle์ ๋ค์์ ์ถ๊ฐํด:
plugins {
id 'java'
id 'me.champeau.jmh' version '0.7.1'
}
dependencies {
jmh 'org.openjdk.jmh:jmh-core:1.37'
jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
}
- โ JDK 8 ์ด์ ์ค์น (JDK 11 ์ด์ ๊ถ์ฅ)
- โ Maven 3.x ๋๋ Gradle 7.x ์ด์
- โ ์ถฉ๋ถํ ๋ฉ๋ชจ๋ฆฌ (์ต์ 2GB, ๊ถ์ฅ 4GB ์ด์)
- โ IDE ์ค์ (IntelliJ IDEA, Eclipse ๋ฑ์์ annotation processing ํ์ฑํ)
- โ ๋ฒค์น๋งํฌ ์คํ ์ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ ์ข ๋ฃ (์ ํํ ์ธก์ ์ ์ํด)
๐ ์ฒซ ๋ฒ์งธ ๋ฒค์น๋งํฌ ์์ฑํ๊ธฐ
์ด์ ์ค์ ๋ก ๋ฒค์น๋งํฌ๋ฅผ ์์ฑํด๋ณด์! ๊ฐ์ฅ ๊ฐ๋จํ ์์ ๋ถํฐ ์์ํ ๊ฒ. ๐
์๋ฅผ ๋ค์ด, String ์ฐ๊ฒฐ ๋ฐฉ๋ฒ๋ค์ ์ฑ๋ฅ์ ๋น๊ตํด๋ณด์. + ์ฐ์ฐ์, StringBuilder, StringBuffer ์ค ์ด๋ค ๊ฒ ๊ฐ์ฅ ๋น ๋ฅผ๊น?
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class StringConcatenationBenchmark {
private static final int ITERATIONS = 1000;
@Benchmark
public String testPlusOperator() {
String result = "";
for (int i = 0; i < ITERATIONS; i++) {
result += "a";
}
return result;
}
@Benchmark
public String testStringBuilder() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ITERATIONS; i++) {
sb.append("a");
}
return sb.toString();
}
@Benchmark
public String testStringBuffer() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < ITERATIONS; i++) {
sb.append("a");
}
return sb.toString();
}
}
์! ์ฝ๋๊ฐ ์ข ๋ณต์กํด ๋ณด์ด์ง? ๐ ํ๋์ฉ ๋ฏ์ด๋ณด๋ฉด ์ ํ ์ด๋ ต์ง ์์. ๊ฐ ์ด๋ ธํ ์ด์ ์ด ๋ฌด์จ ์ญํ ์ ํ๋์ง ์์๋ณด์!
| ์ด๋ ธํ ์ด์ | ์ค๋ช | ์ฃผ์ ์ต์ |
|---|---|---|
| @Benchmark | ๋ฒค์น๋งํฌ ๋์ ๋ฉ์๋ ํ์ | - |
| @BenchmarkMode | ์ธก์ ๋ฐฉ์ ์ง์ | Throughput, AverageTime, SampleTime, SingleShotTime, All |
| @OutputTimeUnit | ๊ฒฐ๊ณผ ์ถ๋ ฅ ์๊ฐ ๋จ์ | NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS |
| @State | ๋ฒค์น๋งํฌ ์ํ ๊ฐ์ฒด ๋ฒ์ | Thread, Group, Benchmark |
| @Warmup | ์๋ฐ์ ์ค์ | iterations(๋ฐ๋ณต ํ์), time(์๊ฐ), timeUnit(์๊ฐ ๋จ์) |
| @Measurement | ์ค์ ์ธก์ ์ค์ | iterations, time, timeUnit |
| @Fork | JVM ํ๋ก์ธ์ค ๋ถ๋ฆฌ ํ์ | ๊ฐ์ด ํด์๋ก ์ ๋ขฐ์ฑ ๋์ง๋ง ์๊ฐ ์ค๋ ๊ฑธ๋ฆผ |
โข Throughput: ๋จ์ ์๊ฐ๋น ๋ช ๋ฒ ์คํ๋๋์ง ์ธก์ (ops/s)
โข AverageTime: ํ ๋ฒ ์คํํ๋ ๋ฐ ํ๊ท ์ ์ผ๋ก ๊ฑธ๋ฆฌ๋ ์๊ฐ
โข SampleTime: ์คํ ์๊ฐ ๋ถํฌ๋ฅผ ์ํ๋ง (๋ฐฑ๋ถ์์ ํ์ธ ๊ฐ๋ฅ)
โข SingleShotTime: ์๋ฐ์ ์์ด ํ ๋ฒ๋ง ์คํ (์ฝ๋ ์คํํธ ์ธก์ )
๋๋ถ๋ถ์ ๊ฒฝ์ฐ Throughput์ด๋ AverageTime์ ์ฌ์ฉํ๋ฉด ๋ผ!
๋ฒค์น๋งํฌ๋ฅผ ์์ฑํ์ผ๋ฉด ์ด์ ์คํํด์ผ๊ฒ ์ง? Maven์ ์ฌ์ฉํ๋ค๋ฉด:
mvn clean install
java -jar target/benchmarks.jar
Gradle์ด๋ผ๋ฉด:
./gradlew jmh
์คํํ๋ฉด JMH๊ฐ ์ด์ฌํ ์ผํ๊ธฐ ์์ํด! ์๋ฐ์ ๋จ๊ณ๋ฅผ ๊ฑฐ์ณ์ ์ค์ ์ธก์ ์ ํ๊ณ , ๋ง์ง๋ง์ ๋ฉ์ง ๊ฒฐ๊ณผ ๋ฆฌํฌํธ๋ฅผ ๋ณด์ฌ์ค. ๐
๐ ๋ฒค์น๋งํฌ ๊ฒฐ๊ณผ ํด์ํ๊ธฐ
๋ฒค์น๋งํฌ๋ฅผ ์คํํ๋ฉด ์ด๋ฐ ์์ ๊ฒฐ๊ณผ๊ฐ ๋์:
Benchmark Mode Cnt Score Error Units
StringConcatenationBenchmark.testPlusOperator avgt 5 45231.456 ยฑ 1234.567 ns/op
StringConcatenationBenchmark.testStringBuilder avgt 5 1234.567 ยฑ 45.678 ns/op
StringConcatenationBenchmark.testStringBuffer avgt 5 1456.789 ยฑ 67.890 ns/op
์ด ๊ฒฐ๊ณผ๋ฅผ ์ด๋ป๊ฒ ์ฝ์ด์ผ ํ ๊น? ๐ค
Cnt (5): 5๋ฒ ์ธก์ ํ์
Score: ํ๊ท ์คํ ์๊ฐ (๋ฎ์์๋ก ๋น ๋ฆ!)
Error (ยฑ): ์ค์ฐจ ๋ฒ์ (์์์๋ก ์์ ์ )
Units (ns/op): ๋๋ ธ์ด per operation
์ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด StringBuilder๊ฐ ์ฝ 37๋ฐฐ ๋น ๋ฅด๊ณ , StringBuffer๋ + ์ฐ์ฐ์๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๋ค๋ ๊ฑธ ์ ์ ์์ด!
ํ์ง๋ง ์ฌ๊ธฐ์ ๋์ด ์๋์ผ! JMH๋ ๋ ์์ธํ ํต๊ณ ์ ๋ณด๋ ์ ๊ณตํด. -v ์ต์ ์ ์ถ๊ฐํ๋ฉด:
java -jar target/benchmarks.jar -v EXTRA
์ด๋ ๊ฒ ํ๋ฉด ๊ฐ iteration๋ณ ๊ฒฐ๊ณผ, GC ์ ๋ณด, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋ฑ ํจ์ฌ ๋ ์์ธํ ๋ฐ์ดํฐ๋ฅผ ๋ณผ ์ ์์ด. ์ง์งํ๊ฒ ์ฑ๋ฅ ๋ถ์ํ ๋๋ ์ด๋ฐ ์ ๋ณด๋ค์ด ์ ๋ง ์ ์ฉํด! ๐
์ซ์๋ง ๋ณด๋ฉด ์ข ์ง๋ฃจํ์ง? JMH๋ ๊ฒฐ๊ณผ๋ฅผ JSON, CSV ๋ฑ ๋ค์ํ ํ์์ผ๋ก ์ถ๋ ฅํ ์ ์์ด:
java -jar target/benchmarks.jar -rf json -rff results.json
์ด๋ ๊ฒ ์ ์ฅํ ๋ฐ์ดํฐ๋ฅผ Excel, Google Sheets, ๋๋ ์ ๋ฌธ ์๊ฐํ ๋๊ตฌ๋ก ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆด ์ ์์ด. ์๊ฐ์ ๋ฐ๋ฅธ ์ฑ๋ฅ ๋ณํ๋ฅผ ์ถ์ ํ๊ฑฐ๋, ์ฌ๋ฌ ๋ฒ์ ์ ๋น๊ตํ ๋ ํนํ ์ ์ฉํ์ง! ๐
๐ ๊ณ ๊ธ JMH ๊ธฐ๋ฅ๋ค
๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ๋ฒ์ ์ตํ๋ค๋ฉด, ์ด์ JMH์ ์ง์ง ๊ฐ๋ ฅํ ๊ธฐ๋ฅ๋ค์ ์์๋ณผ ์ฐจ๋ก์ผ! ๐
@State ์ด๋ ธํ ์ด์ ์ ๋ฒค์น๋งํฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ณต์ ํ ๋ ์ฌ์ฉํด. ์ธ ๊ฐ์ง ์ค์ฝํ๊ฐ ์์ด:
// Thread ์ค์ฝํ: ๊ฐ ์ค๋ ๋๋ง๋ค ๋
๋ฆฝ์ ์ธ ์ธ์คํด์ค
@State(Scope.Thread)
public class MyState {
private List<String> list;
@Setup
public void setup() {
list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add("item" + i);
}
}
@TearDown
public void tearDown() {
list.clear();
}
}
// Benchmark ์ค์ฝํ: ๋ชจ๋ ์ค๋ ๋๊ฐ ๊ณต์
@State(Scope.Benchmark)
public class SharedState {
public volatile int counter = 0;
}
// Group ์ค์ฝํ: ๊ฐ์ ๊ทธ๋ฃน ๋ด ์ค๋ ๋๋ค์ด ๊ณต์
@State(Scope.Group)
public class GroupState {
public Queue<String> queue = new ConcurrentLinkedQueue<>();
}
Benchmark: ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ๋์์ฑ ํ ์คํธํ ๋
Group: ์์ฐ์-์๋น์ ํจํด ๊ฐ์ ํน์ํ ์๋๋ฆฌ์ค
@Setup๊ณผ @TearDown์ ๋ฒค์น๋งํฌ ์ ํ์ ์คํ๋๋ ๋ฉ์๋์ผ. ์ธ ๊ฐ์ง ๋ ๋ฒจ์ด ์์ด:
@State(Scope.Thread)
public class SetupExample {
private Connection connection;
private PreparedStatement statement;
// ์ ์ฒด ๋ฒค์น๋งํฌ ์์ ์ ํ ๋ฒ๋ง ์คํ
@Setup(Level.Trial)
public void setupTrial() {
connection = DriverManager.getConnection("jdbc:...");
System.out.println("DB ์ฐ๊ฒฐ ์๋ฃ");
}
// ๊ฐ iteration ์์ ์ ์คํ
@Setup(Level.Iteration)
public void setupIteration() {
statement = connection.prepareStatement("SELECT * FROM users");
System.out.println("Statement ์ค๋น");
}
// ๊ฐ ๋ฒค์น๋งํฌ ๋ฉ์๋ ํธ์ถ ์ ์คํ
@Setup(Level.Invocation)
public void setupInvocation() {
// ๋งค๋ฒ ์ด๊ธฐํ๊ฐ ํ์ํ ๊ฒฝ์ฐ
// ์ฃผ์: ์ฑ๋ฅ์ ์ํฅ์ ์ค ์ ์์!
}
@TearDown(Level.Trial)
public void tearDownTrial() {
connection.close();
System.out.println("DB ์ฐ๊ฒฐ ์ข
๋ฃ");
}
}
์ฌ๋ฌ ์ ๋ ฅ๊ฐ์ ๋ํด ๋ฒค์น๋งํฌ๋ฅผ ์คํํ๊ณ ์ถ์ ๋ @Param์ ์ฌ์ฉํด:
@State(Scope.Thread)
public class CollectionBenchmark {
@Param({"100", "1000", "10000"})
private int size;
@Param({"ArrayList", "LinkedList", "Vector"})
private String type;
private List<Integer> list;
@Setup
public void setup() {
switch (type) {
case "ArrayList":
list = new ArrayList<>(size);
break;
case "LinkedList":
list = new LinkedList<>();
break;
case "Vector":
list = new Vector<>(size);
break;
}
for (int i = 0; i < size; i++) {
list.add(i);
}
}
@Benchmark
public int testIteration() {
int sum = 0;
for (int value : list) {
sum += value;
}
return sum;
}
}
์ด๋ ๊ฒ ํ๋ฉด JMH๊ฐ ์๋์ผ๋ก ๋ชจ๋ ์กฐํฉ(3 ร 3 = 9๊ฐ์ง)์ ๋ํด ๋ฒค์น๋งํฌ๋ฅผ ์คํํด์ค! ๐
๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด ์ด๋ค ์ปฌ๋ ์
์ด ์ด๋ค ํฌ๊ธฐ์์ ๊ฐ์ฅ ํจ์จ์ ์ธ์ง ํ๋์ ์ ์ ์์ง.
JIT ์ปดํ์ผ๋ฌ๋ ๋๋ํด์ "์ด ์ฝ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฐ๋ค?"ํ๊ณ ์์ ์คํ์ ๊ฑด๋๋ธ ์ ์์ด. ์ด๋ฅผ ๋ฐฉ์งํ๋ ค๋ฉด Blackhole์ ์ฌ์ฉํด:
@Benchmark
public void testWithBlackhole(Blackhole blackhole) {
// ์ด ๊ฐ์ด ์ฌ์ฉ๋์ง ์์ผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ์ต์ ํ๋ก ์ ๊ฑฐํ ์ ์์
int result = expensiveCalculation();
// Blackhole์ ๋ฃ์ผ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ์ ๊ฑฐํ์ง ๋ชปํจ
blackhole.consume(result);
}
@Benchmark
public int testWithReturn() {
// ๋๋ return์ผ๋ก ๊ฐ์ ๋ฐํํ๋ฉด ๋จ
return expensiveCalculation();
}
private int expensiveCalculation() {
int sum = 0;
for (int i = 0; i < 1000; i++) {
sum += i * i;
}
return sum;
}
๋๋ก๋ ํน์ ๋ฉ์๋์ ์ธ๋ผ์ด๋์ ๋ง๊ฑฐ๋ ๊ฐ์ ํ๊ณ ์ถ์ ๋๊ฐ ์์ด:
import org.openjdk.jmh.annotations.CompilerControl;
public class CompilerControlExample {
// ์ธ๋ผ์ด๋ ๋ฐฉ์ง - ๋ฉ์๋ ํธ์ถ ์ค๋ฒํค๋ ์ธก์ ์
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
private int dontInlineMe(int x) {
return x * x;
}
// ์ธ๋ผ์ด๋ ๊ฐ์ - ์์ํ ๊ณ์ฐ ์ฑ๋ฅ ์ธก์ ์
@CompilerControl(CompilerControl.Mode.INLINE)
private int inlineMe(int x) {
return x + x;
}
// ์ปดํ์ผ ์ ์ธ - ์ธํฐํ๋ฆฌํฐ ๋ชจ๋๋ก ์คํ
@CompilerControl(CompilerControl.Mode.EXCLUDE)
private int excludeMe(int x) {
return x - x;
}
@Benchmark
public int testCompilerControl() {
return dontInlineMe(10) + inlineMe(20) + excludeMe(30);
}
}
๐ช ์ค์ ๋ฒค์น๋งํน ์๋๋ฆฌ์ค
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ๋ก ์ ์ฉํ ๋ฒค์น๋งํฌ ์์ ๋ค์ ์ดํด๋ณด์! ์ค๋ฌด์์ ์์ฃผ ๋ง์ฃผ์น๋ ์ํฉ๋ค์ด์ผ. ๐ผ
Jackson, Gson, JSON-B ์ค ์ด๋ค ๊ฒ ๊ฐ์ฅ ๋น ๋ฅผ๊น? ์ค์ ๋ก ์ธก์ ํด๋ณด์:
@State(Scope.Thread)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class JsonBenchmark {
private ObjectMapper jacksonMapper;
private Gson gson;
private Jsonb jsonb;
private String jsonString;
private User user;
@Setup
public void setup() {
jacksonMapper = new ObjectMapper();
gson = new Gson();
jsonb = JsonbBuilder.create();
user = new User("John Doe", 30, "john@example.com");
jsonString = "{\"name\":\"John Doe\",\"age\":30,\"email\":\"john@example.com\"}";
}
@Benchmark
public String jacksonSerialize() throws Exception {
return jacksonMapper.writeValueAsString(user);
}
@Benchmark
public User jacksonDeserialize() throws Exception {
return jacksonMapper.readValue(jsonString, User.class);
}
@Benchmark
public String gsonSerialize() {
return gson.toJson(user);
}
@Benchmark
public User gsonDeserialize() {
return gson.fromJson(jsonString, User.class);
}
@Benchmark
public String jsonbSerialize() throws Exception {
return jsonb.toJson(user);
}
@Benchmark
public User jsonbDeserialize() throws Exception {
return jsonb.fromJson(jsonString, User.class);
}
public static class User {
private String name;
private int age;
private String email;
// ์์ฑ์, getter, setter ์๋ต
}
}
์ด ๋ฒค์น๋งํฌ๋ฅผ ์คํํ๋ฉด ๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ง๋ ฌํ/์ญ์ง๋ ฌํ ์ฑ๋ฅ์ ops/s(์ด๋น ์์ ์)๋ก ๋น๊ตํ ์ ์์ด. ์ผ๋ฐ์ ์ผ๋ก Jackson์ด ๊ฐ์ฅ ๋น ๋ฅด์ง๋ง, ํ๋ก์ ํธ ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์์ผ๋ ์ง์ ์ธก์ ํ๋ ๊ฒ ์ค์ํด! ๐ฏ
HashMap, ConcurrentHashMap, Caffeine Cache์ ์ฑ๋ฅ์ ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ๋น๊ตํด๋ณด์:
@State(Scope.Benchmark)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class CacheBenchmark {
private Map<String, String> hashMap;
private Map<String, String> concurrentHashMap;
private Cache<String, String> caffeineCache;
@Param({"1", "4", "8", "16"})
private int threads;
@Setup
public void setup() {
hashMap = Collections.synchronizedMap(new HashMap<>());
concurrentHashMap = new ConcurrentHashMap<>();
caffeineCache = Caffeine.newBuilder()
.maximumSize(10000)
.build();
// ์ด๊ธฐ ๋ฐ์ดํฐ ๋ก๋ฉ
for (int i = 0; i < 1000; i++) {
String key = "key" + i;
String value = "value" + i;
hashMap.put(key, value);
concurrentHashMap.put(key, value);
caffeineCache.put(key, value);
}
}
@Benchmark
@Threads(Threads.MAX)
public String testHashMap() {
String key = "key" + ThreadLocalRandom.current().nextInt(1000);
return hashMap.get(key);
}
@Benchmark
@Threads(Threads.MAX)
public String testConcurrentHashMap() {
String key = "key" + ThreadLocalRandom.current().nextInt(1000);
return concurrentHashMap.get(key);
}
@Benchmark
@Threads(Threads.MAX)
public String testCaffeineCache() {
String key = "key" + ThreadLocalRandom.current().nextInt(1000);
return caffeineCache.getIfPresent(key);
}
}
@Threads(Threads.MAX)๋ฅผ ์ฌ์ฉํ๋ฉด JMH๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ชจ๋ CPU ์ฝ์ด๋ฅผ ํ์ฉํด์ ํ ์คํธํด. ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์์ ์ค์ ์ฑ๋ฅ์ ํ์ธํ ์ ์์ง! ๐ฅ
Java 8์ Stream API๊ฐ ์ ๋ง ๋๋ฆด๊น? ์ง์ ํ์ธํด๋ณด์:
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class StreamBenchmark {
@Param({"100", "1000", "10000", "100000"})
private int size;
private List<Integer> numbers;
@Setup
public void setup() {
numbers = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
numbers.add(ThreadLocalRandom.current().nextInt(1000));
}
}
@Benchmark
public long testForLoop() {
long sum = 0;
for (int i = 0; i < numbers.size(); i++) {
int num = numbers.get(i);
if (num % 2 == 0) {
sum += num * num;
}
}
return sum;
}
@Benchmark
public long testEnhancedForLoop() {
long sum = 0;
for (Integer num : numbers) {
if (num % 2 == 0) {
sum += num * num;
}
}
return sum;
}
@Benchmark
public long testStream() {
return numbers.stream()
.filter(n -> n % 2 == 0)
.mapToLong(n -> n * n)
.sum();
}
@Benchmark
public long testParallelStream() {
return numbers.parallelStream()
.filter(n -> n % 2 == 0)
.mapToLong(n -> n * n)
.sum();
}
}
๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด ํฅ๋ฏธ๋ก์ด ์ฌ์ค์ ๋ฐ๊ฒฌํ ์ ์์ด:
โข ์์ ๋ฐ์ดํฐ์
(~1000): ์ ํต์ for๋ฌธ์ด ๊ฐ์ฅ ๋น ๋ฆ
โข ์ค๊ฐ ํฌ๊ธฐ(~10000): Stream๊ณผ for๋ฌธ์ด ๋น์ท
โข ํฐ ๋ฐ์ดํฐ์
(100000+): Parallel Stream์ด ๊ฐ์ฅ ๋น ๋ฆ
"Stream์ ๋ฌด์กฐ๊ฑด ๋๋ฆฌ๋ค"๋ ํธ๊ฒฌ์ด ๊นจ์ง๋ ์๊ฐ์ด์ง! ๐ฒ
2. ์ปจํ ์คํธ๊ฐ ์ค์ํ๋ค: ๋ฐ์ดํฐ ํฌ๊ธฐ, ์ค๋ ๋ ์, ํ๋์จ์ด์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง
3. ํธ๋ ์ด๋์คํ๋ฅผ ๊ณ ๋ คํ๋ผ: ์ฑ๋ฅ๋ง์ด ์ ๋ถ๊ฐ ์๋์ผ. ๊ฐ๋ ์ฑ, ์ ์ง๋ณด์์ฑ๋ ์ค์!
4. ์ค์ ํ๊ฒฝ๊ณผ ์ ์ฌํ๊ฒ: ๋ฒค์น๋งํฌ ์กฐ๊ฑด์ ์ค์ ์ด์ ํ๊ฒฝ๊ณผ ๋น์ทํ๊ฒ ์ค์ ํด์ผ ์๋ฏธ์์ด
๐จ ๋ฒค์น๋งํน ์ ํํ ์ค์์ ํด๊ฒฐ๋ฒ
JMH๋ฅผ ์ฌ์ฉํ๋๋ผ๋ ์๋ชป๋ ๋ฐฉ์์ผ๋ก ๋ฒค์น๋งํฌ๋ฅผ ์์ฑํ๋ฉด ์๋ฑํ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ์ ์์ด. ์ค์ ๋ก ๋ง์ ๊ฐ๋ฐ์๋ค์ด ํ๋ ์ค์๋ค์ ์์๋ณด์! ๐ฐ
// ์๋ชป๋ ๋ฐฉ๋ฒ
@Benchmark
public void wrongWay() {
for (int i = 0; i < 1000; i++) {
doSomething();
}
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ
@Benchmark
@OperationsPerInvocation(1000)
public void rightWay() {
for (int i = 0; i < 1000; i++) {
doSomething();
}
}
// ๋๋ ๋ ๋์ ๋ฐฉ๋ฒ
@Benchmark
public void bestWay() {
doSomething(); // JMH๊ฐ ์์์ ๋ฐ๋ณตํด์ค
}
@OperationsPerInvocation์ ์ฌ์ฉํ๋ฉด JMH์๊ฒ "ํ ๋ฒ ํธ์ถ์ ์ค์ ๋ก๋ 1000๋ฒ์ ์์ ์ด ์ผ์ด๋๋ค"๊ณ ์๋ ค์ค ์ ์์ด. ์ด๋ ๊ฒ ํ๋ฉด ๊ฒฐ๊ณผ๊ฐ ์ ํํ๊ฒ ๊ณ์ฐ๋ผ!
// ์๋ชป๋ ๋ฐฉ๋ฒ - ์ค๋ ๋ ์์ ํ์ง ์์
@State(Scope.Thread)
public class WrongState {
private int counter = 0; // ๊ฐ ์ค๋ ๋๋ง๋ค ๋
๋ฆฝ์
@Benchmark
public int wrongBenchmark() {
return counter++; // ๋ฉํฐ์ค๋ ๋์์ ๋ฌธ์ ๋ฐ์ ๊ฐ๋ฅ
}
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ 1 - Benchmark ์ค์ฝํ ์ฌ์ฉ
@State(Scope.Benchmark)
public class RightState1 {
private AtomicInteger counter = new AtomicInteger(0);
@Benchmark
public int rightBenchmark() {
return counter.incrementAndGet();
}
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ 2 - ๊ฐ ์ค๋ ๋ ๋
๋ฆฝ์ ์ผ๋ก
@State(Scope.Thread)
public class RightState2 {
private int counter = 0;
@Benchmark
public int rightBenchmark() {
return counter++; // Thread ์ค์ฝํ์์๋ ์์
}
}
// ์๋ชป๋ ์ค์ - ์๋ฐ์
๋๋ฌด ์งง์
@Warmup(iterations = 1, time = 1)
@Measurement(iterations = 2, time = 1)
public class InsufficientWarmup {
@Benchmark
public void test() {
// JIT ์ปดํ์ผ๋ฌ๊ฐ ์ต์ ํํ ์๊ฐ์ด ๋ถ์กฑ!
}
}
// ์ฌ๋ฐ๋ฅธ ์ค์
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(value = 3, warmups = 1) // 3๋ฒ fork, ๊ฐ๊ฐ 1๋ฒ ์ถ๊ฐ ์๋ฐ์
public class ProperWarmup {
@Benchmark
public void test() {
// ์ถฉ๋ถํ ์๋ฐ์
์ผ๋ก ์์ ์ ์ธ ๊ฒฐ๊ณผ!
}
}
โข ๋ณต์กํ ์ฐ์ฐ: 5-10 iterations
โข ๋คํธ์ํฌ/DB ์์ : 10-20 iterations
โข ๊ฐ iteration์ ์ต์ 1์ด ์ด์ ๊ถ์ฅ
// ์๋ชป๋ ๋ฐฉ๋ฒ - Dead Code Elimination ์ํ
@Benchmark
public void wrongWay() {
int result = expensiveCalculation();
// result๋ฅผ ์ฌ์ฉํ์ง ์์ - ์ปดํ์ผ๋ฌ๊ฐ ์ ๊ฑฐํ ์ ์์!
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ 1 - return ์ฌ์ฉ
@Benchmark
public int rightWay1() {
return expensiveCalculation();
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ 2 - Blackhole ์ฌ์ฉ
@Benchmark
public void rightWay2(Blackhole bh) {
int result = expensiveCalculation();
bh.consume(result);
}
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ 3 - ์ฌ๋ฌ ๊ฐ์ ์๋น
@Benchmark
public void rightWay3(Blackhole bh) {
int result1 = calculation1();
int result2 = calculation2();
bh.consume(result1);
bh.consume(result2);
}
// ์๋ชป๋ ์ค์ - Fork ์์
@Fork(0) // ๊ฐ์ JVM์์ ์คํ - ์ด์ ํ
์คํธ์ ์ํฅ ๋ฐ์
public class NoFork {
@Benchmark
public void test() { }
}
// ์ฌ๋ฐ๋ฅธ ์ค์
@Fork(value = 3, jvmArgs = {"-Xms2G", "-Xmx2G"})
public class ProperFork {
@Benchmark
public void test() { }
}
// ๊ฐ๋ฐ ์ค์๋ ๋น ๋ฅธ ํ
์คํธ๋ฅผ ์ํด
@Fork(value = 1, warmups = 0) // ๋น ๋ฅธ ํผ๋๋ฐฑ
public class DevFork {
@Benchmark
public void test() { }
}
// ์ต์ข
์ธก์ ์์๋
@Fork(value = 5, warmups = 2) // ์ ๋ขฐ์ฑ ๋์ ๊ฒฐ๊ณผ
public class ProductionFork {
@Benchmark
public void test() { }
}
๐จ JMH ๊ฒฐ๊ณผ ๋ถ์ ๋ฐ ์ต์ ํ ์ ๋ต
๋ฒค์น๋งํฌ๋ฅผ ์คํํ๋ค๋ฉด, ์ด์ ๊ฒฐ๊ณผ๋ฅผ ์ ๋๋ก ๋ถ์ํ๊ณ ์ค์ ์ต์ ํ๋ก ์ฐ๊ฒฐํด์ผ๊ฒ ์ง? ๐
JMH ๊ฒฐ๊ณผ๋ฅผ ๋ณผ ๋ ๊ฐ์ฅ ์ค์ํ ๊ฑด ์ค์ฐจ ๋ฒ์(Error)์ผ. ์๋ฅผ ๋ค์ด:
Benchmark Mode Cnt Score Error Units
Method1 avgt 5 100.5 ยฑ 2.3 ns/op
Method2 avgt 5 98.7 ยฑ 5.1 ns/op
์ด ๊ฒฝ์ฐ Method2๊ฐ ์ฝ๊ฐ ๋น ๋ฅด์ง๋ง, ์ค์ฐจ ๋ฒ์๋ฅผ ๊ณ ๋ คํ๋ฉด (98.7-5.1=93.6 ~ 98.7+5.1=103.8) ์ค์ ๋ก๋ Method1๊ณผ ๊ฑฐ์ ์ฐจ์ด๊ฐ ์์ด! ํต๊ณ์ ์ผ๋ก ์ ์๋ฏธํ ์ฐจ์ด๊ฐ ์๋๋ผ๋ ๊ฑฐ์ง. ๐
์์ฌ์ค๋ฌ์ด ์ฐจ์ด: ์ค์ฐจ ๋ฒ์๊ฐ ์ฝ๊ฐ ๊ฒน์น ๋ (์: 100ยฑ5 vs 95ยฑ5)
์ฐจ์ด ์์: ์ค์ฐจ ๋ฒ์๊ฐ ํฌ๊ฒ ๊ฒน์น ๋ (์: 100ยฑ10 vs 98ยฑ12)
์ผ๋ฐ์ ์ผ๋ก 10% ์ด์ ์ฐจ์ด๊ฐ ๋์ผ ์๋ฏธ์๋ ์ต์ ํ๋ก ๋ณผ ์ ์์ด!
JMH๋ ๋ค์ํ ํ๋กํ์ผ๋ฌ์ ํตํฉํ ์ ์์ด. ์ฑ๋ฅ ๋ณ๋ชฉ์ ์ฐพ๋ ๋ฐ ์ ๋ง ์ ์ฉํด!
// ๋ช
๋ น์ค์์ ํ๋กํ์ผ๋ฌ ์ฌ์ฉ
java -jar target/benchmarks.jar -prof gc // GC ํ๋กํ์ผ๋ง
java -jar target/benchmarks.jar -prof stack // ์คํ ํ๋กํ์ผ๋ง
java -jar target/benchmarks.jar -prof perf // Linux perf ํตํฉ
// ์ฝ๋์์ ํ๋กํ์ผ๋ฌ ์ง์
@Fork(value = 1, jvmArgs = {"-XX:+PrintGCDetails"})
public class ProfiledBenchmark {
@Benchmark
public void test() { }
}
ํนํ -prof gc๋ ์ ๋ง ์ ์ฉํด! GC๊ฐ ์ผ๋ง๋ ์์ฃผ ๋ฐ์ํ๋์ง, ์ผ๋ง๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋์ง ๋ณด์ฌ์ค:
Benchmark Mode Cnt Score Error Units
MyBenchmark.test avgt 5 100.5 ยฑ 2.3 ns/op
MyBenchmark.test:ยทgc.alloc.rate avgt 5 2000.0 ยฑ 50.0 MB/sec
MyBenchmark.test:ยทgc.alloc.rate.norm avgt 5 200.0 ยฑ 5.0 B/op
MyBenchmark.test:ยทgc.count avgt 5 10.0 counts
gc.alloc.rate.norm์ด ํนํ ์ค์ํด! ์ด๊ฑด "ํ ๋ฒ ์์ ํ ๋ ํ๊ท ์ ์ผ๋ก ์ผ๋ง๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋๊ฐ"๋ฅผ ๋ณด์ฌ์ค. ์ด ๊ฐ์ด ํฌ๋ฉด GC ์๋ฐ์ด ํฌ๋ค๋ ๋ป์ด์ผ. ๐๏ธ
์ค์ ๋ก JMH๋ก ๋ฐ๊ฒฌํ๊ณ ์ต์ ํํ ์ฌ๋ก๋ฅผ ๋ณด์:
// ์ต์ ํ ์ - String concatenation in loop
@Benchmark
public String beforeOptimization() {
String result = "";
for (int i = 0; i < 100; i++) {
result += "item" + i + ",";
}
return result;
}
// ๊ฒฐ๊ณผ: 45,231 ns/op, gc.alloc.rate.norm: 51,200 B/op
// ์ต์ ํ ํ - StringBuilder ์ฌ์ฉ
@Benchmark
public String afterOptimization() {
StringBuilder sb = new StringBuilder(1000);
for (int i = 0; i < 100; i++) {
sb.append("item").append(i).append(",");
}
return sb.toString();
}
// ๊ฒฐ๊ณผ: 1,234 ns/op, gc.alloc.rate.norm: 1,024 B/op
// ์ฑ๋ฅ ํฅ์: ์ฝ 37๋ฐฐ!
// ๋ฉ๋ชจ๋ฆฌ ํ ๋น: 50๋ฐฐ ๊ฐ์!
์ด๋ฐ ์์ผ๋ก JMH๋ฅผ ์ฌ์ฉํ๋ฉด ์ ํํ ์์น๋ก ์ต์ ํ ํจ๊ณผ๋ฅผ ์ฆ๋ช ํ ์ ์์ด! ์ฝ๋ ๋ฆฌ๋ทฐ์์ "์ด๊ฒ ๋ ๋น ๋ฅผ ๊ฒ ๊ฐ์์"๊ฐ ์๋๋ผ "๋ฒค์น๋งํฌ ๊ฒฐ๊ณผ 37๋ฐฐ ๋นจ๋ผ์ก์ต๋๋ค"๋ผ๊ณ ๋งํ ์ ์์ง. ๐
๐ JMH ๋ฒ ์คํธ ํ๋ํฐ์ค
์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ์ ๋ฆฌํด์, JMH๋ฅผ ํจ๊ณผ์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฒ ์คํธ ํ๋ํฐ์ค๋ฅผ ์์๋ณด์! ๐
โข ์ด๋ค ์กฐ๊ฑด์์ ์ธก์ ํ ๊ฒ์ธ๊ฐ? (๋จ์ผ ์ค๋ ๋? ๋ฉํฐ ์ค๋ ๋?)
โข ๊ฒฐ๊ณผ๋ฅผ ์ด๋ป๊ฒ ํ์ฉํ ๊ฒ์ธ๊ฐ? (์ต์ ํ? ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ํ?)
โข ์ผ๋ง๋ ์ ํํ ์ธก์ ์ด ํ์ํ๊ฐ? (๋น ๋ฅธ ํผ๋๋ฐฑ? ์ ๋ฐํ ๋ถ์?)
| ์ํฉ | ์ถ์ฒ ๋ชจ๋ | ์ด์ |
|---|---|---|
| API ์ฒ๋ฆฌ๋ ์ธก์ | Throughput | ์ด๋น ์ฒ๋ฆฌ ๊ฐ๋ฅํ ์์ฒญ ์๊ฐ ์ค์ |
| ์๋ต ์๊ฐ ์ธก์ | AverageTime | ์ฌ์ฉ์ ๊ฒฝํ์ ์ง์ ์ ์ํฅ |
| ์ต์ ์ ๊ฒฝ์ฐ ๋ถ์ | SampleTime | 99 percentile ๋ฑ ํ์ธ ๊ฐ๋ฅ |
| ์ด๊ธฐํ ์ฑ๋ฅ | SingleShotTime | ์ฝ๋ ์คํํธ ์๋๋ฆฌ์ค |
| ์ข ํฉ ๋ถ์ | All | ๋ชจ๋ ๊ด์ ์์ ํ๊ฐ |
// ๋์ ์ - ๋นํ์ค์ ์ธ ๋ฐ์ดํฐ
@State(Scope.Thread)
public class UnrealisticBenchmark {
private List<String> data = Arrays.asList("a", "b", "c");
@Benchmark
public void test() {
// ์ค์ ๋ก๋ ์์ฒ~์๋ง ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋๋ฐ...
}
}
// ์ข์ ์ - ์ค์ ํ๊ฒฝ๊ณผ ์ ์ฌํ ๋ฐ์ดํฐ
@State(Scope.Thread)
public class RealisticBenchmark {
private List<User> users;
@Setup
public void setup() {
users = new ArrayList<>();
// ์ค์ ์ด์ ํ๊ฒฝ์ ํ๊ท ๋ฐ์ดํฐ ํฌ๊ธฐ
for (int i = 0; i < 10000; i++) {
users.add(generateRealisticUser());
}
}
private User generateRealisticUser() {
// ์ค์ ์ฌ์ฉ์ ๋ฐ์ดํฐ์ ์ ์ฌํ ํจํด
return new User(
generateName(),
ThreadLocalRandom.current().nextInt(18, 80),
generateEmail()
);
}
}
// ๋ฒค์น๋งํฌ ๊ฒฐ๊ณผ๋ฅผ ํ์ผ๋ก ์ ์ฅ
java -jar target/benchmarks.jar -rf json -rff results-v1.0.json
// Git์ ๊ฒฐ๊ณผ ์ปค๋ฐ
git add results-v1.0.json
git commit -m "Benchmark results for version 1.0"
// ๋์ค์ ๋น๊ต
java -jar target/benchmarks.jar -rf json -rff results-v1.1.json
# ๋ ๊ฒฐ๊ณผ๋ฅผ ๋น๊ตํ์ฌ ์ฑ๋ฅ ๋ณํ ์ถ์
์ด๋ ๊ฒ ํ๋ฉด ์๊ฐ์ ๋ฐ๋ฅธ ์ฑ๋ฅ ๋ณํ๋ฅผ ์ถ์ ํ ์ ์์ด. ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ์ ๋ ์ฑ๋ฅ์ด ๋จ์ด์ก๋์ง ๋ฐ๋ก ์ ์ ์์ง! ๐
// Maven pom.xml์ ์ถ๊ฐ
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>run-benchmarks</id>
<phase>integration-test</phase>
<goals>
<goal>exec</goal>
</goals>
<configuration>
<executable>java</executable>
<arguments>
<argument>-jar</argument>
<argument>target/benchmarks.jar</argument>
<argument>-rf</argument>
<argument>json</argument>
</arguments>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
โข ๋ฒค์น๋งํฌ ์คํ ์๊ฐ์ด ๊ธธ์ด์ง ์ ์์ผ๋ ๋ณ๋ ํ์ดํ๋ผ์ธ ๊ตฌ์ฑ
โข ์ฑ๋ฅ ์๊ณ๊ฐ์ ์ค์ ํ์ฌ ํ๊ท ์๋ ๊ฐ์ง
โข ๊ฒฐ๊ณผ๋ฅผ ์๊ฐํํ์ฌ ํ์๋ค๊ณผ ๊ณต์
/**
* String ์ฐ๊ฒฐ ๋ฐฉ๋ฒ๋ค์ ์ฑ๋ฅ์ ๋น๊ตํ๋ ๋ฒค์น๋งํฌ
*
* ํ
์คํธ ํ๊ฒฝ:
* - CPU: Intel i7-9700K @ 3.6GHz
* - RAM: 16GB DDR4
* - JDK: OpenJDK 17.0.2
* - OS: Ubuntu 22.04 LTS
*
* ๊ฒฐ๊ณผ ์์ฝ (2024-01-15):
* - StringBuilder: 1,234 ns/op (๊ฐ์ฅ ๋น ๋ฆ)
* - StringBuffer: 1,456 ns/op
* - + ์ฐ์ฐ์: 45,231 ns/op (๊ฐ์ฅ ๋๋ฆผ)
*
* ๊ฒฐ๋ก : ๋ฐ๋ณต์ ์ธ ๋ฌธ์์ด ์ฐ๊ฒฐ์๋ StringBuilder ์ฌ์ฉ ๊ถ์ฅ
*
* @see <a href="https://github.com/yourproject/benchmarks">๋ฒค์น๋งํฌ ์ ์ฅ์</a>
*/
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class StringConcatenationBenchmark {
// ๋ฒค์น๋งํฌ ์ฝ๋...
}
๐ ๋ง๋ฌด๋ฆฌ: JMH๋ก ์ฑ๋ฅ ์ ๋ฌธ๊ฐ ๋๊ธฐ
์, ์ฌ๊ธฐ๊น์ง JMH๋ฅผ ํ์ฉํ ์๋ฐ ์ฑ๋ฅ ๋ฒค์น๋งํน์ ๋ํด ๊น์ด ์๊ฒ ์์๋ดค์ด! ๐
์ฒ์์๋ "๊ทธ๋ฅ System.currentTimeMillis()๋ก ์ฌ๋ฉด ๋์ง ์๋?"๋ผ๊ณ ์๊ฐํ์ ์๋ ์์ง๋ง, ์ด์ ๋ ์ JMH๊ฐ ํ์ํ์ง, ์ด๋ป๊ฒ ์ฌ์ฉํด์ผ ํ๋์ง ํ์คํ ์๊ฒ ๋์ ๊ฑฐ์ผ.
โข ํต๊ณ์ ์ผ๋ก ์ ๋ขฐํ ์ ์๋ ๊ฒฐ๊ณผ ์ ๊ณต
โข Dead Code Elimination ๊ฐ์ ํจ์ ์๋ ๋ฐฉ์ง
2. ์ฌ๋ฐ๋ฅธ ์ฌ์ฉ๋ฒ
โข ๋ช ํํ ๋ชฉํ ์ค์ ๊ณผ ์ ์ ํ ์ธก์ ๋ชจ๋ ์ ํ
โข ์ถฉ๋ถํ ์๋ฐ์ ๊ณผ ์ธก์ ๋ฐ๋ณต
โข ํ์ค์ ์ธ ํ ์คํธ ๋ฐ์ดํฐ์ ํ๊ฒฝ
โข ๊ฒฐ๊ณผ์ ํต๊ณ์ ์ ์๋ฏธ์ฑ ๊ฒ์ฆ
3. ์ค์ ํ์ฉ
โข ์๊ณ ๋ฆฌ์ฆ ๋น๊ต, ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ํ, ์ฝ๋ ์ต์ ํ
โข CI/CD ํ์ดํ๋ผ์ธ ํตํฉ์ผ๋ก ์ฑ๋ฅ ํ๊ท ๋ฐฉ์ง
โข ํ๊ณผ ๊ฒฐ๊ณผ ๊ณต์ ํ์ฌ ์ง๋จ ์ง์ ํฅ์
JMH๋ฅผ ๋ง์คํฐํ๋ค๋ฉด ์ด์ ์ด๋ฐ ๊ฒ๋ค๋ ์๋ํด๋ณผ ์ ์์ด:
| ์ฃผ์ | ์ค๋ช | ๋์ด๋ |
|---|---|---|
| Async Profiler ํตํฉ | ํ์ผ ๊ทธ๋ํ๋ก ์ฑ๋ฅ ๋ณ๋ชฉ ์๊ฐํ | โญโญโญ |
| JMH Visualizer | ๋ฒค์น๋งํฌ ๊ฒฐ๊ณผ๋ฅผ ์น์์ ์๊ฐํ | โญโญ |
| JFR๊ณผ ํตํฉ | Java Flight Recorder๋ก ์์ธ ๋ถ์ | โญโญโญโญ |
| ์ปค์คํ ํ๋กํ์ผ๋ฌ | ํน์ ๋ฉํธ๋ฆญ์ ์ํ ํ๋กํ์ผ๋ฌ ๊ฐ๋ฐ | โญโญโญโญโญ |
| ๋ถ์ฐ ๋ฒค์น๋งํน | ์ฌ๋ฌ ์๋ฒ์์ ๋์ ์ธก์ | โญโญโญโญ |
์ด์ ๋น์ ์ ํ๋ก์ ํธ์ JMH๋ฅผ ์ ์ฉํด๋ณผ ์ฐจ๋ก์ผ! ์์ ๊ฒ๋ถํฐ ์์ํด๋ด:
1๋จ๊ณ: ๊ฐ์ฅ ์์ฃผ ํธ์ถ๋๋ ๋ฉ์๋ ํ๋๋ฅผ ๊ณจ๋ผ ๋ฒค์น๋งํฌ ์์ฑ
2๋จ๊ณ: ํ์ฌ ์ฑ๋ฅ์ ์ธก์ ํ๊ณ ๊ธฐ๋ก
3๋จ๊ณ: ์ต์ ํ ์์ด๋์ด๋ฅผ ์ ์ฉํ๊ณ ๋ค์ ์ธก์
4๋จ๊ณ: ๊ฒฐ๊ณผ๋ฅผ ํ๊ณผ ๊ณต์ ํ๊ณ ํผ๋๋ฐฑ ๋ฐ๊ธฐ
5๋จ๊ณ: ์ ์ง์ ์ผ๋ก ๋ ๋ง์ ๋ถ๋ถ์ ์ ์ฉ
์ด๋ ๊ฒ ํ๋ค ๋ณด๋ฉด ์ด๋์ ๋น์ ๋ ์ฑ๋ฅ ์ต์ ํ ์ ๋ฌธ๊ฐ๊ฐ ๋์ด ์์ ๊ฑฐ์ผ! ๐ช
โข JMH Samples: JMH ์ ์ฅ์์ jmh-samples ๋ชจ๋
โข Aleksey Shipilรซv์ ๋ธ๋ก๊ทธ: JMH ์ฐฝ์์์ ์ฌํ ๋ด์ฉ
โข Java Performance: The Definitive Guide: ์ค์ฝง ์คํฌ์ค์ ๋ช ์
โข ์ฌ๋ฅ๋ท ์ ๋ฌธ๊ฐ ์๋ด: ์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ๊ฐ๋ฐ์๋ค์ 1:1 ๋ฉํ ๋ง
์ฑ๋ฅ ์ต์ ํ๋ ๋์๋ ์ฌ์ ์ด์ผ. ํ์ง๋ง JMH๋ผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ๋ฅผ ์์ ๋ฃ์ ์ง๊ธ, ๋น์ ์ ์ด๋ฏธ ์ฌ๋ฐ๋ฅธ ๊ธธ์ ๊ฑท๊ณ ์์ด. ๐
๊ธฐ์ตํด, ์ธก์ ํ์ง ์์ผ๋ฉด ๊ฐ์ ํ ์ ์์ด. JMH๋ก ์ ํํ๊ฒ ์ธก์ ํ๊ณ , ๋ฐ์ดํฐ ๊ธฐ๋ฐ์ผ๋ก ์์ฌ๊ฒฐ์ ํ๊ณ , ์ง์์ ์ผ๋ก ๊ฐ์ ํด๋๊ฐ์!
ํ์ด์ ๋น์ด! ๊ทธ๋ฆฌ๊ณ ๋ฉ์ง ๋ฒค์น๋งํฌ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ฒ ๋๋ฉด ํ์๋ค๊ณผ ๊ผญ ๊ณต์ ํด์ค. ์ง์์ ๋๋์๋ก ๋ ๊ฐ์น์์ด์ง๋๊น! ๐
๐ฏ ์ด ๊ธ์ด ๋์์ด ๋์๋์?
๋ ๊น์ด ์๋ ์ฑ๋ฅ ์ต์ ํ ์ง์์ด ํ์ํ๋ค๋ฉด,
์ฌ๋ฅ๋ท์์ ์ ๋ฌธ๊ฐ์ ํจ๊ป ๋น์ ์ ์ฝ๋๋ฅผ ํ ๋จ๊ณ ์
๊ทธ๋ ์ด๋ํ์ธ์! ๐ก
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.