Giám sát mức sử dụng bộ nhớ heap của luồng ảo

Kể từ khi Java 21 giới thiệu luồng ảo (Virtual Threads), khả năng xử lý đồng thời đã được cải thiện đáng kể nhờ vào tính nhẹ của chúng. Tuy nhiên, việc tạo ra hàng loạt luồng ảo vẫn có thể gây áp lực lên bộ nhớ heap. Do đó, việc theo dõi mức sử dụng heap là yếu tố then chốt để tối ưu hiệu suất.

Kích hoạt tác tử ghi nhật ký bộ nhớ JVM

Để theo dõi thời gian thực mức sử dụng heap liên quan đến luồng ảo, cần bật chức năng ghi nhật ký tích hợp sẵn của JVM. Sử dụng tham số khởi động sau để kích hoạt Java Flight Recorder (JFR):

java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=recording.jfr -jar myapp.jar

Lệnh này sẽ sinh ra một file ghi dữ liệu hiệu suất kéo dài 60 giây, bao gồm các chỉ số như phân bổ luồng và biến động bộ nhớ heap.

Phân tích hành vi bộ nhớ heap của luồng ảo

Mặc dù luồng ảo không chiếm dụng trực tiếp bộ nhớ stack (vì dùng chung stack của carrier thread), nhưng các đối tượng nhiệm vụ, biến cục bộ và closure vẫn được cấp phát trên heap. Cần chú ý đến các điểm tiêu thụ bộ nhớ sau:

• Đối tượng nhiệm vụ (Runnable/Callable) mà mỗi luồng ảo thực thi
• Các đối tượng lớn hoặc tập hợp dữ liệu được giữ bên trong nhiệm vụ
• Sự tích tụ thông tin stack trace khi xảy ra lỗi liên tục

Sử dụng JMC để xem xét phân bổ bộ nhớ theo luồng

Java Mission Control (JMC) cho phép phân tích trực quan file JFR. Các bước chính:

1. Mở JMC và nhập file recording.jfr
2. Chuyển sang tab "Memory", kiểm tra phần "Object Statistics" để xem phân bố thể hiện
3. Lọc theo sự kiện jdk.VirtualThreadSubmit nhằm xác định điểm nóng về phân bổ bộ nhớ

Mối quan hệ giữa luồng ảo và bộ nhớ heap

Luồng ảo là thành phần cốt lõi của Project Loom, mang lại mô hình bộ nhớ khác biệt rõ rệt so với luồng nền tảng truyền thống.

Mô hình bộ nhớ và cơ chế cấp phát heap

Thay vì gắn cố định với một luồng hệ điều hành, luồng ảo được lập lịch bởi JVM, giảm đáng kể chi phí bộ nhớ stack. Chúng sử dụng stack có kích thước thay đổi, cấp phát động từ heap khi thực thi — trái ngược với luồng nền tảng vốn dành trước stack cố định (thường vài MB).

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 50_000; i++) {
        executor.submit(() -> {
            var data = new byte[512]; // Đối tượng sống ngắn
            try { Thread.sleep(50); } catch (InterruptedException e) {}
        });
    }
}

Trong ví dụ trên, mỗi nhiệm vụ tạo ra một luồng ảo. Dữ liệu cục bộ và ngữ cảnh thực thi đều được lưu trữ trên heap dưới dạng đối tượng do JVM quản lý. Mặc dù footprint của từng luồng rất nhỏ (chỉ vài KB), nhưng ở quy mô lớn, tổng lượng đối tượng tạm thời sinh ra có thể làm tăng tần suất GC ở vùng young gen.

So sánh với luồng nền tảng

Dưới đây là bảng so sánh mức tiêu thụ bộ nhớ giữa hai loại luồng:

Việc chuyển từ luồng nền tảng sang luồng ảo giúp mở rộng quy mô đồng thời lên 100 lần mà không làm cạn kiệt bộ nhớ.

Những nguyên nhân phổ biến gây rò rỉ bộ nhớ heap

Rò rỉ bộ nhớ thường xảy ra do:

• Tập hợp tĩnh giữ tham chiếu: Sử dụng static Map hoặc List để lưu dữ liệu mà không xóa mục cũ, dẫn đến tích tụ đối tượng không thể thu hồi.
• Callback hoặc listener chưa hủy đăng ký: Trong mô hình pub-sub hoặc GUI, nếu không hủy đăng ký sự kiện, đối tượng sẽ bị framework giữ mạnh, ngăn GC thực hiện công việc.

Chuẩn bị môi trường và tinh chỉnh JVM

Để đảm bảo dữ liệu giám sát chính xác, cần cấu hình JVM phù hợp:

-Xms2g -Xmx2g
-XX:+UseG1GC
-Dcom.sun.management.jmxremote.port=9999
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false

Các tùy chọn này thiết lập heap ổn định (2GB), kích hoạt G1GC cho hiệu năng tốt hơn, và mở cổng JMX để kết nối từ xa — lý tưởng cho cả môi trường thử nghiệm và sản xuất (nên bật xác thực trong production).

Theo dõi hành vi bộ nhớ bằng JFR

JFR là công cụ then chốt để phân tích luồng ảo từ JDK 21 trở đi.

Bắt sự kiện luồng ảo

JFR ghi nhận các sự kiện quan trọng như:

• jdk.VirtualThreadStart: Khi luồng ảo bắt đầu
• jdk.VirtualThreadEnd: Khi kết thúc
• jdk.VirtualThreadPinned: Khi bị "ghim" vào carrier thread, ảnh hưởng hiệu năng

Dùng lệnh sau để trích xuất điểm ghim:

jfr print --events jdk.VirtualThreadPinned recording.jfr

Phân tích mẫu phân bổ và chuỗi giữ tham chiếu

Để phát hiện rò rỉ, cần xác định đường dẫn từ gốc GC tới đối tượng sống sót. Công cụ như Eclipse MAT hỗ trợ chức năng "Merge Shortest Paths to GC Roots" để tìm ra container toàn cục đang giữ tham chiếu.

Thực tiễn: Xử lý tích tụ do PhantomReference

PhantomReference dùng để theo dõi giải phóng bộ nhớ, nhưng nếu không xử lý đúng với ReferenceQueue, nó có thể gây tắc nghẽn:

ReferenceQueue<Object> queue = new ReferenceQueue<>();
List<PhantomReference<Object>> refs = new ArrayList<>();

for (int i = 0; i < 10_000; i++) {
    Object obj = new byte[1024 * 1024];
    refs.add(new PhantomReference<>(obj, queue));
}
// Thiếu: consumer thread gọi queue.remove()

Khắc phục bằng cách khởi động một luồng phụ để tiêu thụ hàng đợi và dọn dẹp các tham chiếu đã hoàn tất.

Chẩn đoán chuyên sâu với JVMTI và công cụ bên thứ ba

Sử dụng Eclipse MAT phân tích heap dump

Eclipse Memory Analyzer (MAT) hỗ trợ xác định thể hiện java.lang.VirtualThread trong heap dump. Qua "Histogram", ta lọc và kiểm tra từng luồng ảo. Chức năng "Paths to GC Roots" giúp phát hiện đối tượng bị giữ do tham chiếu vô tình.

Async-Profiler: Tạo biểu đồ lửa và lấy mẫu hiệu suất

Async-Profiler hoạt động với chi phí thấp, thu thập dữ liệu CPU, phân bổ bộ nhớ và khóa. Ví dụ lấy mẫu CPU:

./profiler.sh -e cpu -d 30 -f flame.html <jvm-pid>

Kết quả là một biểu đồ lửa (flame graph) dạng HTML, hiển thị rõ ràng các hàm tiêu tốn nhiều tài nguyên.

Xây dựng bảng giám sát thời gian thực với Prometheus + Grafana

Hệ thống giám sát hiện đại cần tích hợp nhiều thành phần:

1. Triển khai Prometheus để thu thập chỉ số qua HTTP
2. Cấu hình scrape_configs trỏ đến ứng dụng hoặc agent như Micrometer
3. Kết nối Grafana với Prometheus làm nguồn dữ liệu
4. Tạo dashboard theo dõi số lượng luồng ảo, tỷ lệ GC, và mức sử dụng heap

scrape_configs:
  - job_name: 'java-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8080']

Viết Agent tùy chỉnh để giám sát phân bổ

Dùng kỹ thuật tăng cường bytecode (ví dụ với ASM) để can thiệp vào lớp VirtualThread:

public class AllocationTrackingAgent implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className, ... byte[] classfileBuffer) {
        if ("java/lang/VirtualThread".equals(className)) {
            ClassReader cr = new ClassReader(classfileBuffer);
            ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
            cr.accept(new MethodVisitor(ASM_VERSION, cw) {
                // Chèn logic đếm tại điểm vào run()
            }, 0);
            return cw.toByteArray();
        }
        return classfileBuffer;
    }
}

Agent này có thể theo dõi số lượng đối tượng được tạo ra bởi mỗi luồng ảo, từ đó phát hiện các nhiệm vụ gây áp lực bất thường lên heap.

Xu hướng tương lai trong giám sát hiệu suất

Quan sát học (observability) đang thay thế mô hình giám sát truyền thống. Ba trụ cột chính là metrics, logging và tracing — minh họa rõ qua OpenTelemetry:

import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.GlobalOpenTelemetry;

void handleRequest() {
    Tracer tracer = GlobalOpenTelemetry.getTracer("my-service");
    var span = tracer.spanBuilder("process.request").startSpan();
    try (var scope = span.makeCurrent()) {
        businessLogic();
    } finally {
        span.end();
    }
}

AI ngày càng đóng vai trò quan trọng trong phát hiện dị thường: xây dựng ngưỡng động, phân tích đa chiều, và đề xuất nguyên nhân gốc. Các công nghệ như eBPF (BCC, Pixie) hay Telegraf+MQTT cũng mở rộng khả năng giám sát xuống tận tầng kernel và thiết bị biên.

Một xu hướng nổi bật là cảnh báo tự động hóa: khi chỉ số vượt ngưỡng → AI phân tích → kích hoạt kịch bản (như scale-out) → cập nhật trạng thái lên hệ thống chat — tạo thành vòng khép kín.