Multithreading hoạt động như thế nào trong Java?

Question

Accepted Answer

**Multithreading** cho phép một chương trình Java chạy nhiều thread đồng thời, mang lại tính song song (sử dụng nhiều core CPU) và tính phản hồi (làm việc mà không bị chặn). Java có hỗ trợ thread hạng nhất — nhưng trạng thái thay đổi được dùng chung (shared mutable state) gây ra sự phức tạp (race condition) phải được quản lý cẩn thận. ## Tạo thread ```java // 1. Implement Runnable (được ưa chuộng — tách task khỏi thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() chạy nó trên một thread MỚI (run() sẽ chạy trên thread HIỆN TẠI!) // 2. hiện đại: dùng ExecutorService thay vì thread thô ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Lỗi thường gặp then chốt:** gọi `start()` (sinh ra một thread mới), không phải `run()` (chỉ chạy code trên thread hiện tại một cách đồng bộ). ## Vấn đề cốt lõi: race condition ```java // ❌ nhiều thread sửa đổi trạng thái dùng chung → kết quả không thể đoán trước class Counter { int count = 0; void increment() { count++; } // KHÔNG nguyên tử: đọc → cộng → ghi (có thể xen kẽ) } // 1000 thread mỗi thread tăng 1000 lần → count cuối cùng thường < 1.000.000! ``` `count++` thực ra là ba thao tác (đọc, tăng, ghi). Khi các thread xen kẽ nhau, các cập nhật bị mất — một **race condition**. Đây là thách thức trung tâm của concurrency: trạng thái thay đổi được dùng chung bị truy cập bởi nhiều thread mà không có sự phối hợp. ## Giải pháp cho trạng thái dùng chung an toàn ```java // 1. synchronized — chỉ một thread trong method/block tại một thời điểm (một lock) synchronized void increment() { count++; } // 2. atomic class — các thao tác nguyên tử không cần lock AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // nguyên tử, thread-safe, hiệu quả // 3. concurrent collection — được xây dựng cho truy cập đa luồng ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. tính bất biến (immutability) — object bất biến vốn dĩ đã thread-safe (không có gì để hỏng) ``` ## Phối hợp thread ```java t.join(); // chờ thread t hoàn thành Thread.sleep(1000); // tạm dừng thread hiện tại // còn có: wait()/notify(), CountDownLatch, lock, v.v. để phối hợp ``` ## Cách tiếp cận hiện đại: đừng quản lý thread thô ```text ✓ Dùng ExecutorService / thread pool (không new Thread() cho mỗi task — tốn kém) ✓ Dùng CompletableFuture để kết hợp các thao tác async ✓ Dùng concurrent collection và atomic class thay vì đồng bộ hóa thủ công ✓ Java 21+ bổ sung Virtual Thread — hàng triệu thread nhẹ cho concurrency I/O ``` ## Tại sao điều này quan trọng Multithreading cho phép các chương trình Java sử dụng nhiều core và duy trì tính phản hồi, nhưng nó cũng là một trong những lĩnh vực khó làm đúng nhất — **race condition** từ trạng thái thay đổi được dùng chung không được đồng bộ hóa gây ra các bug chập chờn, khó tái hiện. Hiểu cách thread hoạt động (`start()` so với `run()`), vấn đề race-condition cốt lõi (tại sao `count++` không an toàn), và các công cụ để đảm bảo an toàn (`synchronized`, atomic class, concurrent collection, tính bất biến) là thiết yếu để viết code concurrent đúng đắn. Thực hành tốt nhất hiện đại ưu tiên các trừu tượng cấp cao hơn (ExecutorService, CompletableFuture, virtual thread) thay vì quản lý thread thô. Đây là kiến thức then chốt cho Java phía server và hiệu năng cao, và là một chủ đề sâu, thường được kiểm tra giúp phân biệt lập trình viên giỏi với lập trình viên chuyên gia.