Trọn bộ câu hỏi phỏng vấn Java Core 2026 – Phiên bản dài, rất dàiii

Đây là bản nâng cao của Trọn bộ câu hỏi phỏng vấn Java Core: bỏ qua cú pháp, OOP và collection đã có ở bản ngắn, tập trung vào JVM, bộ nhớ, concurrency, hiệu năng và những gì Java 25–27 thay đổi.

Cập nhật 2026

  • Java 25 LTS là baseline production; Java 27 (GA 09/2026) là feature release hiện tại, không phải LTS.
  • synchronized không còn pin virtual thread từ Java 24 (JEP 491).
  • Scoped Values final ở Java 25; Structured Concurrency vẫn preview ở Java 27.
  • G1 mặc định ở mọi môi trường từ Java 27; compact object headers bật mặc định.

Câu hỏi phỏng vấn Java Core nâng cao: JVM và bộ nhớ

Heap, stack và metaspace: cái gì nằm ở đâu?

Object và array nằm trên heap, chia sẻ giữa các thread và do GC quản lý. Stack là per-thread: mỗi frame giữ tham số, biến local và reference; frame biến mất khi method return nên primitive local không cần GC. Metaspace là native memory chứa metadata class — bytecode, constant pool, descriptor — tách khỏi heap từ Java 8. Static field nằm trong object Class trên heap.

Java Memory Model: happens-before, visibility và reordering là gì?

JMM quy định khi nào thread này thấy giá trị thread khác ghi, qua happens-before: program order, monitor, volatile, Thread.start/join, final field. Thiếu quan hệ này, compiler và CPU được phép reorder hoặc cache giá trị trong register, nên có thể đọc mãi giá trị cũ. volatile tạo happens-before cho mỗi lần đọc/ghi và chặn reorder quanh nó, nhưng không làm count++ atomic.

public final class ConfigHolder {
    private static volatile ConfigHolder instance;

    private ConfigHolder() {}

    public static ConfigHolder get() {
        ConfigHolder local = instance;
        if (local == null) {
            synchronized (ConfigHolder.class) {
                local = instance;
                if (local == null) instance = local = new ConfigHolder();
            }
        }
        return local;
    }
}

GC cơ bản: young/old, G1, ZGC, Shenandoah — chọn cái nào?

Heap chia young (Eden, hai survivor) và old. G1 chia heap thành region, ưu tiên region rác nhiều, mặc định từ Java 9 và từ Java 27 ở mọi môi trường. ZGC giữ pause gần như không đổi với heap rất lớn, generational mặc định từ Java 23; Shenandoah low-pause, generational final ở Java 25 nhưng không có trong Oracle JDK. Chọn G1; ZGC khi SLA pause chặt; Shenandoah khi dùng OpenJDK build.

JIT chạy thế nào và tại sao benchmark tay hay sai?

HotSpot dùng tiered compilation: interpreter thu thập profile, C1 biên dịch nhanh kèm profiling, C2 tối ưu mạnh dựa trên giả định về class hierarchy và tần suất branch. Khi giả định sai, JVM deoptimize về interpreter — bình thường, không phải lỗi. Benchmark tự viết hay sai vì JIT loại dead code, constant-fold, và warm-up chiếm phần lớn thời gian đo. Dùng JMH với warmup, fork và Blackhole.

AOT và CDS: startup nhanh hơn ở đâu, đổi lại cái gì?

CDS map sẵn archive class vào bộ nhớ để giảm startup; AppCDS mở rộng cho class của ứng dụng. Từ Java 24, AOT cache gộp loading, linking và profiling; Java 26 thêm AOT object caching với mọi GC. Lợi ích ở startup và footprint, không phải throughput đỉnh. GraalVM native image đổi lại bằng build lâu, closed-world nên phải khai báo reflection/resource, peak thấp hơn JIT và profiling hạn chế.

JFR: ghi gì trên production và overhead ra sao?

JFR là profiler tích hợp, ghi event vào file nhị phân với overhead thấp, thiết kế để chạy liên tục trên production. Bật bằng -XX:StartFlightRecording hoặc jcmd <pid> JFR.start. Đáng ghi: allocation sample, old object sample, GC pause, lock contention, socket/thread, exception, method profiling. Đừng bật mọi event cùng lúc. Đọc bằng jfr print hoặc JDK Mission Control.

Memory leak trong Java trông như thế nào?

GC chỉ thu object không còn reachable, nên “leak” là reference bị giữ ngoài ý muốn: static Map làm cache không giới hạn, ThreadLocal không remove() trong thread pool, listener không hủy, classloader của bản deploy cũ bị giữ. Dấu hiệu: old gen tăng đều qua các Full GC, heap dump phình dần. Chẩn đoán bằng heap dump + dominator tree hoặc JFR old object sample.

Concurrency

Platform thread và virtual thread khác nhau ở đâu?

Platform thread ánh xạ 1:1 với OS thread, tốn stack và context switch; lifecycle là NEW → RUNNABLE → BLOCKED/WAITING/TIMED_WAITING → TERMINATED. Virtual thread final từ Java 21, mount/unmount trên carrier nên tạo được hàng triệu cái. Chúng thắng ở workload I/O-bound vì thời gian chờ không chiếm carrier; CPU-bound thì không nhanh hơn. Từ Java 24, pinning do synchronized đã bị bỏ; pin còn lại chủ yếu ở native frame.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<Result>> futures = ids.stream()
        .map(id -> executor.submit(() -> fetch(id)))
        .toList();
    for (Future<Result> f : futures) results.add(f.get());
}

synchronized hay ReentrantLock?

synchronized là intrinsic lock: tự release khi ra khỏi block hoặc ném exception, nhưng không timeout, không interrupt, không fairness. ReentrantLock cho tryLock(timeout), lockInterruptibly, fairness qua constructor và nhiều Condition. Mặc định dùng synchronized; chuyển sang ReentrantLock khi cần timeout để tránh deadlock hoặc hủy theo interrupt. Nhớ unlock() trong finally.

volatile, Atomic* và LongAdder khác nhau thế nào?

volatile chỉ đảm bảo visibility và ordering, không atomicity: hai thread cùng count++ vẫn mất update. AtomicInteger/AtomicLong dùng CAS, đúng cho counter và trạng thái đơn, nhưng contention cao thì retry nhiều. LongAdder tách cell theo thread rồi cộng khi đọc, tốt cho metric đếm; đổi lại sum() không atomic và không hợp làm số dư.

Thread pool: sizing, queue và rejection policy?

CPU-bound đặt gần số core khả dụng; I/O-bound cần nhiều hơn hoặc dùng virtual thread thay vì phình platform thread. Queue phải bounded — ArrayBlockingQueue hay SynchronousQueue thể hiện ý định rõ hơn LinkedBlockingQueue mặc định. Rejection policy là thiết kế: AbortPolicy báo lỗi, CallerRunsPolicy tạo backpressure, DiscardPolicy âm thầm mất việc. Queue vô hạn chỉ đổi OOM thành latency.

int cores = Runtime.getRuntime().availableProcessors();
var pool = new ThreadPoolExecutor(
    cores, cores, 0, TimeUnit.MILLISECONDS,
    new ArrayBlockingQueue<>(1_000),
    new ThreadPoolExecutor.CallerRunsPolicy());

CompletableFuture: ghép chuỗi và bẫy thường gặp?

thenApply biến đổi giá trị, thenCompose nối một future khác, thenCombine ghép hai future độc lập. Exception chỉ chảy trong chuỗi nếu bạn xử lý bằng handle, exceptionally hoặc whenComplete; quên thì lỗi biến mất. Bẫy hay gặp: gọi get/join trong thread request, chạy I/O blocking trên common ForkJoinPool, và không có timeout. Truyền executor riêng và đặt orTimeout.

Structured concurrency giải quyết vấn đề gì?

Nó nhóm subtask vào một scope: subtask không sống lâu hơn scope, một task fail thì phần còn lại bị hủy, thread dump hiện cây task thay vì hàng trăm thread rời rạc. Đó là điều executor tự do và CompletableFuture không bảo đảm. API là StructuredTaskScope, vẫn preview ở Java 27 (lần thứ bảy), cần --enable-preview và có thể đổi, nên chưa dùng production.

Scoped Values thay ThreadLocal trong trường hợp nào?

ScopedValue final ở Java 25: giá trị immutable, gắn với scope và mất khi scope kết thúc, nên không có kiểu rò rỉ ThreadLocal trong thread pool. Nó nhẹ hơn khi có hàng triệu virtual thread và được kế thừa có kiểm soát vào subtask. ThreadLocal vẫn hợp cho cache theo thread hoặc trạng thái mutable.

Deadlock: phát hiện và phòng ngừa?

Deadlock cần bốn điều kiện đồng thời: mutual exclusion, hold-and-wait, no preemption, circular wait; phá một điều kiện là đủ. Thực tế: đặt thứ tự lock toàn cục theo id, không giữ lock khi gọi service khác, dùng tryLock có timeout. Phát hiện bằng thread dump (jstack) tìm chu trình “found one Java-level deadlock”, JFR lock event hoặc ThreadMXBean.findDeadlockedThreads.

ConcurrentHashMap: atomicity đến đâu?

Map không khóa toàn bộ; computeIfAbsent chỉ atomic trong phạm vi một key, nên mapping function phải ngắn và tuyệt đối không sửa chính map đó — Java 9+ ném IllegalStateException. Giá trị null không được phép. size() và iteration là weakly consistent: có thể thấy update đồng thời, không phải snapshot. Đừng check-then-act bằng containsKey rồi put; dùng compute hoặc merge.

Parallel stream khi nào có hại?

Parallel stream dùng chung common ForkJoinPool, mặc định ít thread hơn số core, và mọi parallel stream trong JVM chia nhau pool đó. Nó thắng khi CPU-bound, dữ liệu lớn, spliterator chia tốt, không I/O và không trạng thái chia sẻ. Nó thua khi collection nhỏ, có bước blocking, hoặc chạy trong request thread. Đo bằng JMH trước khi đổi.

Nâng cao

Class loading, reflection và dynamic proxy tốn kém ở đâu?

Classloader đi theo bootstrap → platform → application, delegation parent-first; class trải qua load → link (verify, prepare, resolve) → init. Reflection tốn vì kiểm tra quyền, boxing và không inline; MethodHandle nhanh hơn nhưng vẫn chậm hơn call trực tiếp. JDK dynamic proxy chỉ hoạt động với interface; CGLIB sinh subclass nên proxy được class cụ thể, trừ final class/method. Spring AOP dùng cả hai.

Vì sao deserialization là lỗ hổng?

readObject là thực thi code: nó chạy constructor của cả hierarchy và có thể tạo object không qua constructor, đủ để gadget chain biến dữ liệu thành RCE. Vì vậy không deserialize dữ liệu không tin cậy. Nếu buộc dùng, đặt ObjectInputFilter allow-list (JEP 290) qua jdk.serialFilter. Ưu tiên JSON/records; serialVersionUID chỉ lo tương thích, không phải bảo mật.

JPMS trong thực tế dùng thế nào?

JPMS chia code thành module qua module-info: requires, exports, opens. Từ Java 17, strong encapsulation bật mặc định nên reflection vào internal JDK bị chặn trừ khi --add-opens. Spring Boot chạy classpath và tự mở những gì framework cần; JPMS hữu ích khi ship library hoặc dùng jlink tạo runtime nhỏ. Đừng module hóa monolith chỉ vì hình thức.

BigDecimal: scale, rounding và tiền tệ?

BigDecimal lưu unscaled value và scale, nên 1.0 và 1.00 khác equals nhưng compareTo bằng 0. Phép chia phải chỉ định scale và RoundingMode, nếu không sẽ ArithmeticException với kết quả vô hạn. Tiền nên dùng minor unit (long) hoặc BigDecimal với scale cố định; HALF_EVEN giảm sai lệch tích lũy, HALF_UP là thói quen phổ biến — chọn theo hợp đồng.

Instant, LocalDateTime hay ZonedDateTime?

Instant là mốc UTC, dùng cho timestamp và so sánh. LocalDateTime không có zone nên không đại diện một thời điểm — đừng dùng cho audit hay expiry. ZonedDateTime gắn zone rule, cần khi hiển thị hoặc tính lịch. DST tạo gap (giờ không tồn tại) và overlap (giờ lặp), nên lưu UTC hoặc timestamptz và convert ở biên.

Text block, pattern matching, record và sealed trong code review?

Text block dùng cho SQL/JSON nhiều dòng, nhớ indentation có ý nghĩa và trailing space bị cắt. Pattern matching cho switch final từ Java 21; kết hợp sealed để compiler kiểm tra exhaustive. Record phù hợp DTO và value object, nhưng component mutable thì mất ý nghĩa bất biến, và không dùng record làm entity JPA.

Test concurrency sao cho không flaky?

Test phải deterministic: inject Clock, Executor và latch thay vì phụ thuộc thời gian thật; dùng CyclicBarrier để đưa nhiều thread vào cùng điểm. Awaitility là thư viện phổ biến để chờ điều kiện kèm timeout — không dùng Thread.sleep, vừa flaky vừa chậm. Với race condition thật, chạy lặp hoặc dùng jcstress; Testcontainers cho phần cần DB/Redis thật.

Observability cho service Java gồm những gì?

Ba trụ: metric, trace và log có correlation id. Micrometer đo Timer, Counter, Gauge, DistributionSummary và xuất Prometheus/OTel; đặt tên theo bounded tag để tránh cardinality nổ. Micrometer Tracing 1.7.x thay Sleuth đã archive; Boot 4 có starter OpenTelemetry. Log nên structured và mang traceId/spanId; MDC dựa trên ThreadLocal nên khi đổi thread phải propagate.

Java 26/27 có gì đáng nhắc trong phỏng vấn?

HTTP/3 cho HttpClient final ở Java 26 (JEP 517). Java 27 đưa G1 thành mặc định ở mọi môi trường (JEP 523), bật compact object headers mặc định (JEP 534) và thêm post-quantum hybrid key exchange cho TLS 1.3 (JEP 527). Structured concurrency vẫn preview lần thứ bảy. Java 27 là feature release, không phải LTS.

Câu hỏi hệ thống

Thiết kế rate limiter phân tán?

Xác định scope: per user, per IP hay per API key. Token bucket cho phép burst, sliding window chính xác hơn nhưng tốn bộ nhớ. Một node thì dùng in-process (Resilience4j RateLimiter hoặc Bucket4j). Nhiều node thì state ở Redis, mỗi lần check phải atomic — Lua script hoặc INCR + EXPIRE, không đọc rồi ghi. Trả 429 kèm Retry-After.

Thiết kế API idempotent?

Client gửi Idempotency-Key; server lưu key → trạng thái và response, còn unique index trên key là nguồn sự thật cuối cùng. Request đầu insert key ở trạng thái PROCESSING rồi xử lý; request trùng đọc lại và trả cùng body, hoặc 409 nếu đang chạy. Phải idempotent cả ở tầng ghi: unique constraint, upsert có điều kiện. Đừng chỉ chống trùng ở application layer.

Kể lại một sự cố production: bạn điều tra thế nào?

Xác nhận impact và mốc thời gian, rồi xem metric saturation — CPU, pool, GC, p99 — thay vì đoán. Lấy 2–3 thread dump cách nhau vài giây để biết thread kẹt ở đâu; bật JFR nếu chưa có; so sánh deploy gần nhất. Giảm thiểu trước bằng rollback hoặc tắt feature flag, rồi mới tìm root cause và viết postmortem có timeline.

Đọc tiếp trong series: