Giới thiệu

Lập trình đồng thời có cấu trúc (Structured Concurrency) là một mô hình lập trình được giới thiệu trong Project Loom nhằm quản lý các tác vụ đồng thời một cách có tổ chức. Thay vì tạo ra các luồng hoặc tác vụ chạy độc lập và có nguy cơ rò rỉ tài nguyên, lập trình đồng thời có cấu trúc đảm bảo rằng các tác vụ đồng thời được nhóm lại dưới một phạm vi cụ thể. Khi phạm vi này hoàn tất, tất cả các tác vụ bên trong đều phải hoàn thành hoặc bị hủy bỏ. Điều này làm cho lập trình đồng thời trở nên an toàn hơn, dự đoán được hơn và dễ dàng hơn để lý giải.

Cấu trúc nội dung

• Cách thức hoạt động
• Tại sao nên sử dụng
• Khi nào nên và không nên sử dụng
• Ví dụ với StructuredTaskScope
• Cách thức kết thúc tất cả các Virtual Threads
• Chưa phải là phiên bản cuối cùng

Cách thức hoạt động

Ý tưởng tương tự như lập trình có cấu trúc: cũng giống như mỗi khối mã có một điểm bắt đầu và kết thúc rõ ràng, lập trình đồng thời có cấu trúc đảm bảo rằng các tác vụ đồng thời có một khoảng thời gian sống xác định gắn liền với phạm vi cha của chúng.

Trong Java, điều này được thực hiện thông qua API StructuredTaskScope. Một phạm vi được mở ra, các tác vụ được chia tách bên trong nó, và khi phạm vi được đóng lại, thời gian thực đảm bảo rằng không có tác vụ nào còn chạy vượt quá thời gian sống của phạm vi đó.

Tại sao nên sử dụng

• Chu kỳ sống dự đoán của các tác vụ, tránh rò rỉ luồng.
• Dọn dẹp tự động các tác vụ chưa hoàn thành hoặc thất bại.
• Xử lý lỗi dễ dàng hơn: ngoại lệ từ các tác vụ đồng thời có thể được thu thập và truyền đạt.
• Tính khả thi: các chính sách khác nhau (ShutdownOnFailure, ShutdownOnSuccess) xác định cách nhóm tác vụ hoạt động.
• Làm việc liền mạch với các luồng ảo, giúp quản lý đồng thời cao mà không gặp phải độ phức tạp của lập trình phản ứng.

Khi nào nên và không nên sử dụng

Nên sử dụng khi:

• Bạn cần chạy nhiều tác vụ đồng thời và chờ đợi tất cả hoặc một số trong số chúng.
• Bạn muốn có các quy tắc hủy bỏ và thất bại rõ ràng (nếu một tác vụ thất bại, các tác vụ khác nên dừng lại).
• Bạn đang xây dựng API hoặc dịch vụ mà độ tin cậy và an toàn tài nguyên là rất quan trọng.

Tránh sử dụng khi:

• Bạn cần các tác vụ có thời gian sống cực dài hoặc các dịch vụ nền cần tồn tại lâu hơn các caller của chúng.
• Bạn đã sử dụng một mô hình đồng thời khác (ví dụ: luồng phản ứng) và không muốn trộn lẫn các mô hình này.
• Tải công việc của bạn không được hưởng lợi từ đồng thời (thực thi tuần tự có thể đơn giản và nhanh hơn).

Ví dụ với StructuredTaskScope

Ví dụ: StructuredTaskScope cơ bản

import java.util.concurrent.*;

public class StructuredConcurrencyExample {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope<String>()) {
            Future<String> task1 = scope.fork(() -> fetchUserData());
            Future<String> task2 = scope.fork(() -> fetchOrderData());

            scope.join(); // Chờ tất cả tác vụ hoàn thành
            scope.throwIfFailed(); // Truyền đạt ngoại lệ

            String result = task1.resultNow() + " | " + task2.resultNow();
            System.out.println("Kết quả: " + result);
        }
    }

    static String fetchUserData() throws InterruptedException {
        Thread.sleep(500);
        return "Dữ liệu người dùng";
    }

    static String fetchOrderData() throws InterruptedException {
        Thread.sleep(700);
        return "Dữ liệu đơn hàng";
    }
}

Ví dụ: StructuredTaskScope.ShutdownOnFailure

import java.util.concurrent.*;

public class ShutdownOnFailureExample {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<String> task1 = scope.fork(() -> fetchData());
            Future<String> task2 = scope.fork(() -> { throw new RuntimeException("Thất bại"); });

            scope.join();           // Chờ cho đến khi tất cả tác vụ hoàn thành hoặc một tác vụ thất bại
            scope.throwIfFailed();  // Ném ngoại lệ từ tác vụ thất bại
        }
    }

    static String fetchData() throws InterruptedException {
        Thread.sleep(500);
        return "Dữ liệu";
    }
}

Ở đây, khi một tác vụ thất bại, tất cả các tác vụ khác sẽ tự động bị hủy bỏ.

Ví dụ: StructuredTaskScope.ShutdownOnSuccess

import java.util.concurrent.*;

public class ShutdownOnSuccessExample {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            scope.fork(() -> { Thread.sleep(700); return "Kết quả chậm"; });
            scope.fork(() -> { Thread.sleep(200); return "Kết quả nhanh"; });

            scope.join();  // Chờ cho đến khi có kết quả thành công đầu tiên
            String result = scope.result();  // Trả về kết quả thành công đầu tiên
            System.out.println("Kết quả: " + result);
        }
    }
}

Ở đây, ngay khi một tác vụ thành công, các tác vụ còn lại sẽ bị hủy bỏ.

Cách thức kết thúc tất cả các Virtual Threads

Các phạm vi lập trình đồng thời có cấu trúc được thiết kế để là cha của các tác vụ mà chúng tạo ra. Khi phạm vi được đóng lại (thông qua try-with-resources hoặc đóng rõ ràng), tất cả các tác vụ chưa hoàn thành trong phạm vi đó sẽ bị hủy bỏ. Vì những tác vụ này thường chạy trên các luồng ảo, việc hủy bỏ chúng có nghĩa là các luồng ảo của chúng sẽ bị ngắt, và thời gian thực đảm bảo rằng chúng sẽ kết thúc một cách an toàn. Điều này tránh việc để lại các luồng mồ côi hoặc chạy không kiểm soát.

Chưa phải là phiên bản cuối cùng

Tính đến tháng 9 năm 2025, Lập trình đồng thời có cấu trúc trong Java vẫn đang trong giai đoạn xem trước. API (StructuredTaskScope) đang phát triển, và một số chi tiết có thể thay đổi trong các phiên bản phát hành trong tương lai trước khi nó trở thành tiêu chuẩn. Các nhà phát triển nên sử dụng nó để thử nghiệm và chuẩn bị cho tương lai nhưng cần lưu ý rằng cú pháp và hành vi có thể thay đổi trong các phiên bản JDK sắp tới.

Các thực tiễn tốt nhất

• Thực hiện kiểm tra lỗi: Đảm bảo rằng bạn luôn kiểm tra các ngoại lệ từ các tác vụ đồng thời.
• Sử dụng các chính sách hủy bỏ phù hợp: Chọn chính sách hủy bỏ dựa trên yêu cầu của ứng dụng của bạn.
• Tổ chức mã rõ ràng: Giữ cho mã của bạn có cấu trúc rõ ràng để dễ dàng bảo trì và mở rộng.

Cạm bẫy thường gặp

• Không kiểm soát được thời gian sống của tác vụ: Đảm bảo rằng bạn hiểu rõ về thời gian sống của các tác vụ trong phạm vi.
• Tránh lạm dụng các luồng ảo: Sử dụng chúng một cách hợp lý, không nên tạo ra quá nhiều luồng ảo một lúc.

Mẹo hiệu suất

• Tối ưu hóa mã đồng thời: Giảm thiểu các tác vụ nặng nề trong các tác vụ đồng thời.
• Sử dụng các công cụ phân tích hiệu suất: Để theo dõi và tối ưu hóa hiệu suất của ứng dụng của bạn.

Câu hỏi thường gặp (FAQ)

Lập trình đồng thời có cấu trúc là gì?

Lập trình đồng thời có cấu trúc là một mô hình quản lý các tác vụ đồng thời một cách có tổ chức, đảm bảo rằng tất cả các tác vụ đều nằm trong một phạm vi và được quản lý hiệu quả.

Tôi có thể sử dụng lập trình đồng thời có cấu trúc trong phiên bản Java nào?

Lập trình đồng thời có cấu trúc hiện tại vẫn đang trong giai đoạn xem trước và có thể không có sẵn trong các phiên bản Java hiện tại. Hãy theo dõi các bản phát hành mới nhất để biết thêm thông tin.

Tại sao tôi nên sử dụng lập trình đồng thời có cấu trúc?

Nó giúp dễ dàng quản lý các tác vụ đồng thời, giảm nguy cơ rò rỉ tài nguyên và cung cấp các quy tắc rõ ràng cho việc hủy bỏ và thất bại của các tác vụ.

Có bất kỳ nhược điểm nào không?

Một số nhược điểm có thể bao gồm sự không tương thích với các mô hình đồng thời hiện có và cần có kiến thức vững về lập trình đồng thời để sử dụng hiệu quả.

Làm thế nào để bắt đầu với lập trình đồng thời có cấu trúc?

Bắt đầu bằng cách tìm hiểu về API StructuredTaskScope và thực hiện các ví dụ đơn giản để làm quen với cách thức hoạt động của nó.