Java 26 출시 개요

Java 26이 2026년 3월 정식 릴리스되었다. 10개의 JEP(JDK Enhancement Proposal)가 포함되어 있으며, 5개가 정식 기능으로 확정되었다. 새로운 언어 문법은 없지만 성능 최적화, 라이브러리 추가, 프리뷰 기능의 발전이 핵심이다.

1. AOT 캐시의 GC 확장 (JEP 516)

Project Leyden의 일환으로, HotSpot JVM의 AOT(Ahead-of-Time) 캐시가 모든 가비지 컬렉터에서 동작하도록 확장되었다. 기존에는 Serial GC에서만 지원되던 것이 ZGC와 G1 GC에서도 사용 가능해졌다.

# AOT 캐시 생성 (트레이닝 실행)
java -XX:AOTCacheOutput=app.aot \
     -XX:AOTCacheTraining \
     -jar myapp.jar

# AOT 캐시를 사용한 실행 (ZGC 사용)
java -XX:AOTCache=app.aot \
     -XX:+UseZGC \
     -jar myapp.jar

# 시작 시간 비교
# AOT 없음:  ~2.1초
# AOT 적용:  ~0.8초  (약 60% 단축)

AOT 캐시는 클래스 로딩, JIT 컴파일 결과, 프로파일링 데이터를 미리 저장하여 애플리케이션 시작 시간과 워밍업 시간을 단축한다.

2. Compact Object Headers (JEP 519)

객체 헤더 크기를 기존 96~128비트에서 64비트로 압축하는 실험적 기능이다. 메모리 사용량을 10~20% 절감할 수 있다.

# Compact Object Headers 활성화
java -XX:+UnlockExperimentalVMOptions \
     -XX:+UseCompactObjectHeaders \
     -jar myapp.jar

# JOL로 객체 크기 확인
import org.openjdk.jol.info.ClassLayout;

public class HeaderCheck {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        // 기존: 16바이트 헤더
        // Compact: 8바이트 헤더
    }
}

3. 원시 타입 패턴 매칭 (4차 프리뷰, JEP 530)

패턴 매칭이 원시 타입(int, long, double 등)까지 확장되었다. instanceof와 switch에서 원시 타입을 직접 매칭할 수 있다.

// instanceof에서 원시 타입 패턴
public String classifyScore(Object score) {
    if (score instanceof int s && s >= 90) {
        return "A 등급";
    } else if (score instanceof int s && s >= 80) {
        return "B 등급";
    } else if (score instanceof double d) {
        return "소수점 점수: " + d;
    }
    return "분류 불가";
}

// switch에서 원시 타입 매칭
public String describeValue(Object value) {
    return switch (value) {
        case int i when i > 0    -> "양의 정수: " + i;
        case int i when i == 0   -> "영";
        case int i               -> "음의 정수: " + i;
        case long l              -> "큰 정수: " + l;
        case double d            -> "실수: " + d;
        case String s            -> "문자열: " + s;
        default                  -> "기타";
    };
}

// 안전한 형변환 (손실 없는 변환만 매칭)
long bigValue = 3_000_000_000L;
if (bigValue instanceof int i) {
    // int 범위를 초과하므로 이 블록은 실행되지 않음
    System.out.println(i);
} else {
    System.out.println("int 범위 초과");
}

4. Flexible Constructor Bodies (3차 프리뷰)

생성자에서 super() 또는 this() 호출 전에 코드를 실행할 수 있게 되었다. 입력 검증이나 변환 로직을 생성자 시작 부분에 배치할 수 있다.

public class VerifiedUser extends User {
    
    // 기존: super() 전에 코드 실행 불가
    // Java 26 프리뷰: super() 전에 검증 가능
    public VerifiedUser(String email, String name, int age) {
        // super() 전에 검증 로직 실행 가능
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException(
                "유효하지 않은 이메일: " + email
            );
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException(
                "유효하지 않은 나이: " + age
            );
        }
        String normalized = email.trim().toLowerCase();
        super(normalized, name, age);
    }
}

// 기존에는 별도 정적 메서드가 필요했음
// public VerifiedUser(String email, String name, int age) {
//     super(validate(email), name, age); // 정적 메서드 우회
// }

5. Structured Concurrency (4차 프리뷰)

구조적 동시성 API가 계속 발전하고 있다. 여러 비동기 작업을 구조화된 방식으로 관리할 수 있다.

import java.util.concurrent.StructuredTaskScope;

public record ProductPage(Product product, List reviews, int stock) {}

public ProductPage loadProductPage(long productId) throws Exception {
    try (var scope = StructuredTaskScope.open()) {
        // 3개의 작업을 동시에 실행
        var productTask = scope.fork(() -> 
            productService.findById(productId)
        );
        var reviewsTask = scope.fork(() -> 
            reviewService.findByProductId(productId)
        );
        var stockTask = scope.fork(() -> 
            inventoryService.getStock(productId)
        );
        
        // 모든 작업 완료 대기
        scope.join();
        
        return new ProductPage(
            productTask.get(),
            reviewsTask.get(),
            stockTask.get()
        );
    }
    // scope 벗어나면 미완료 작업 자동 취소
}

// ShutdownOnFailure 정책: 하나 실패 시 전체 취소
try (var scope = StructuredTaskScope.open(
        StructuredTaskScope.Joiner.awaitAllSuccessfulOrThrow())) {
    var task1 = scope.fork(() -> fetchFromPrimary());
    var task2 = scope.fork(() -> fetchFromBackup());
    scope.join();
}

6. Virtual Threads 성능 개선

Java 21에서 정식 도입된 가상 스레드가 Java 26에서 한층 더 최적화되었다. synchronized 블록에서의 피닝(pinning) 문제가 완전히 해결되었다.

import java.util.concurrent.Executors;

// 가상 스레드로 10만 개 동시 요청 처리
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List> futures = new ArrayList<>();
    
    for (int i = 0; i < 100_000; i++) {
        final int id = i;
        futures.add(executor.submit(() -> {
            // 블로킹 I/O도 효율적으로 처리
            var response = httpClient.send(
                HttpRequest.newBuilder()
                    .uri(URI.create("https://api.example.com/items/" + id))
                    .build(),
                HttpResponse.BodyHandlers.ofString()
            );
            return response.body();
        }));
    }
    
    // 결과 수집
    List results = futures.stream()
        .map(f -> {
            try { return f.get(); }
            catch (Exception e) { return "error"; }
        })
        .toList();
}

Java 버전 선택 가이드

프로덕션 환경에서는 Java 21 LTS를 유지하되, Java 25 LTS로의 마이그레이션을 준비하는 것이 현실적인 전략이다. Java 26의 프리뷰 기능들은 개발 환경에서 미리 테스트하여 대비하자.