성능 최적화와 프로파일링 — 자바가 느리다는 편견 깨기

public int sum(int[] arr) {
    int total = 0;
    for (int i = 0; i < arr.length; i++) {
        total += arr[i];
    }
    return total;
}

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
@State(Scope.Benchmark)
public class StringBenchmark {
    private String[] words;

    @Setup
    public void setUp() {
        words = new String[100];
        for (int i = 0; i < 100; i++) words[i] = "word" + i;
    }

    @Benchmark
    public String concatWithPlus() {
        String result = "";
        for (String word : words) result += word;
        return result;  // ← 반환값으로 DCE 방지
    }

    @Benchmark
    public String concatWithBuilder() {
        StringBuilder sb = new StringBuilder();
        for (String word : words) sb.append(word);
        return sb.toString();
    }
}

// 루프 안의 + 연산자 — 매번 새 StringBuilder가 생성됨
String result = "";
for (String s : list) {
    result += s;
    // 바이트코드: new StringBuilder(result).append(s).toString()
}

// StringBuilder를 직접 사용 — 한 번만 생성
StringBuilder sb = new StringBuilder(estimatedSize); // 초기 용량 지정
for (String s : list) {
    sb.append(s);
}
String result = sb.toString();

// ❌ 기본 용량 16에서 시작 → 원소가 많으면 여러 번 리사이징
Map<String, Integer> map = new HashMap<>();

// ✅ 예상 크기를 알면 초기 용량 지정 (load factor 0.75 고려)
// 1000개 원소 → 최소 1000/0.75 = 1334 → 2의 거듭제곱으로 2048
Map<String, Integer> map = new HashMap<>(2048);

// Java 19+에서는 팩토리 메서드 사용
Map<String, Integer> map = HashMap.newHashMap(1000);

// ❌ 오토박싱: 매 반복마다 Long 객체 생성
Long sum = 0L;
for (long i = 0; i < 1_000_000; i++) {
    sum += i; // Long → long → 더하기 → Long (새 객체 생성)
}

// ✅ 프리미티브 타입 사용 — 5~10배 빠름
long sum = 0L;
for (long i = 0; i < 1_000_000; i++) {
    sum += i;
}

// Integer -128 ~ 127은 캐시됨 (JLS 보장)
Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true — 같은 캐시 객체

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // false — 새 객체가 각각 생성됨

// static factory 메서드로 캐시된 인스턴스 활용
Boolean flag = Boolean.valueOf(true);   // Boolean.TRUE 반환
Integer num = Integer.valueOf(42);      // 캐시 범위 내면 기존 객체 반환

public class DateRange {
    // ❌ 매번 새 포매터 생성 — DateTimeFormatter는 스레드 안전
    public String format(LocalDate date) {
        return date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }

    // ✅ 상수로 한 번만 생성
    private static final DateTimeFormatter FORMATTER =
        DateTimeFormatter.ofPattern("yyyy-MM-dd");

    public String formatBetter(LocalDate date) {
        return date.format(FORMATTER);
    }
}

# JVM 시작 시 활성화
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr MyApp

# 실행 중인 프로세스에 동적으로 붙이기
jcmd <PID> JFR.start duration=60s filename=recording.jfr

import jdk.jfr.*;

@Label("주문 처리")
@Description("주문 처리 소요 시간을 기록하는 이벤트")
public class OrderProcessEvent extends Event {
    @Label("주문 ID")
    long orderId;

    @Label("처리 시간(ms)")
    long processingTimeMs;
}

// 사용
public void processOrder(Order order) {
    OrderProcessEvent event = new OrderProcessEvent();
    event.begin();
    doProcess(order);
    event.orderId = order.getId();
    event.processingTimeMs = event.getDuration().toMillis();
    event.commit();
}

int[] primitive = new int[1_000_000];
// 메모리: 약 4MB (4바이트 x 100만)

Integer[] wrapper = new Integer[1_000_000];
// 메모리: 약 28MB (참조 8바이트 + Integer 객체 20바이트 x 100만)
// primitive의 약 7배!

// ❌ 매번 새 빈 리스트 생성
return new ArrayList<>();

// ✅ 불변 빈 리스트 싱글턴 반환
return Collections.emptyList(); // 항상 같은 객체
return List.of();               // Java 11+

// ❌ 바이트 단위 읽기 — 시스템 콜이 매번 발생
try (FileInputStream fis = new FileInputStream("data.bin")) {
    int b;
    while ((b = fis.read()) != -1) {
        process(b); // 1바이트마다 커널 모드 전환
    }
}

// ✅ 버퍼 사용 — 시스템 콜 횟수를 대폭 줄임
try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("data.bin"), 8192)) {
    int b;
    while ((b = bis.read()) != -1) {
        process(b); // 대부분 버퍼에서 읽기
    }
}

try (FileChannel src = FileChannel.open(Paths.get("source.dat"), READ);
     FileChannel dst = FileChannel.open(Paths.get("dest.dat"),
         WRITE, CREATE, TRUNCATE_EXISTING)) {
    // OS 레벨에서 직접 전송 — 유저 공간 복사 없음
    src.transferTo(0, src.size(), dst);
}

try (FileChannel channel = FileChannel.open(Paths.get("large-file.dat"), READ)) {
    // 파일을 가상 메모리에 매핑 — 접근하는 부분만 페이지 단위로 로드
    MappedByteBuffer buffer = channel.map(
        FileChannel.MapMode.READ_ONLY, 0, channel.size());

    while (buffer.hasRemaining()) {
        byte b = buffer.get();
    }
}