Bài học

Mẫu thiết kế hành vi “Observer”: các vai trò Subject và Observer, đăng ký/hủy đăng ký qua addObserver/ removeObserver, và gửi thông báo bằng phương thức notifyObservers. Phân tích mối liên hệ với mô hình sự kiện của Java: button. addActionListener( listener) ; → gọi actionPerformed(). Thực hành với các ví dụ (nhiệt kế và điều hòa, bộ đếm mini và lambda), cũng như vì sao java.util.Observable/ Observer đã lỗi thời và các cách tiếp cận hiện đại hiện có.

Trong bài giảng này, chúng ta tìm hiểu luồng xử lý sự kiện UI — EDT trong Swing và tương đương của nó JavaFX Application Thread, vì sao các thành phần giao diện không an toàn theo luồng và vì sao cửa sổ “bị treo” khi chạy tác vụ nặng. Chúng ta sẽ trình bày các cách làm đúng: đưa tính toán ra nền thông qua new Thread(...), cập nhật giao diện bằng các lời gọi SwingUtilities.invokeLater và Platform.runLater, cũng như sử dụng các công cụ cấp cao SwingWorker<T, V> và Task<V>/ Service<V> để theo dõi tiến độ, hủy và xử lý lỗi.

Vì sao chương trình cần luồng và tính song song: từ giao diện phản hồi tốt đến việc tận dụng tất cả lõi của bộ xử lý. Phân tích sự khác nhau giữa tiến trình và luồng, vai trò của luồng chính main trong JVM, các trường hợp thực tiễn (UI, máy chủ, xử lý tệp) và rủi ro: race condition, deadlock, cũng như các công cụ đồng bộ cơ bản như synchronized. Sẽ có ví dụ đơn giản với Thread và chạy hai tác vụ song song.

Trong bài giảng này, chúng ta tìm hiểu cách khởi chạy luồng trong Java: làm quen với lớp Thread và interface Runnable, học cách gọi start() đúng cách và không nhầm với run(), dùng lớp ẩn danh và biểu thức lambda, khởi chạy nhiều luồng và xem vòng đời ( NEW → RUNNABLE → TERMINATED). Cũng sẽ nói về các phương thức Thread.currentThread(), getName(), chờ bằng join() và các lỗi điển hình như IllegalThreadStateException.

Phân tích vòng đời của luồng trong Java: từ Thread.State (

NEW

,

RUNNABLE

,

BLOCKED

,

WAITING

,

TIMED_WAITING

,

TERMINATED

) đến các chuyển trạng thái giữa chúng. Học cách quản lý luồng bằng Thread.sleep(...), join(), interrupt(), chẩn đoán trạng thái qua isAlive() và getState(), cũng như tránh các phương thức lỗi thời như stop()/ suspend()/ resume(). Cuối cùng — mẹo thực hành và lỗi thường gặp.

Cách truyền tham số vào luồng một cách an toàn thông qua constructor của lớp triển khai Runnable, khi nào nên dùng biểu thức lambda, và vì sao nên khai báo các trường là final. Phân tích mức ưu tiên của luồng: các phương thức setPriority/ getPriority, các hằng Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY và ảnh hưởng của chúng tới bộ lập lịch. Thêm nữa — đặt tên luồng qua constructor, setName/ getName, ví dụ thực hành và các lỗi thường gặp (dùng chung Runnable, setter, kỳ vọng vào mức ưu tiên).

Trong bài giảng này, chúng ta tìm hiểu race condition là gì: khi nhiều luồng đồng thời truy cập dữ liệu dùng chung và kết quả phụ thuộc vào thứ tự lập lịch. Với ví dụ phép tăng counter ++, chúng tôi cho thấy vì sao thao tác này không nguyên tử và vì sao các lần tăng có thể bị mất. Xem xét một case thực tế với tài khoản ngân hàng, các hậu quả trên production và các cách bảo vệ: synchronized, các kiểu nguyên tử từ java.util.concurrent.atomic (ví dụ, AtomicInteger), cũng như tính bất biến (immutability). Kết thúc bằng phần “Lỗi thường gặp”, giải thích vì sao bug liên quan đến Thread hiếm khi bị test bắt được và vì sao “chữa” chúng bằng Thread. sleep( 1) là vô nghĩa.

Bài giảng này nói về tài nguyên dùng chung trong ứng dụng đa luồng là gì, vì sao xuất hiện race condition và “lost update”, và cách bảo vệ dữ liệu bằng synchronized. Chúng ta sẽ tìm hiểu các kỹ thuật đồng bộ cơ bản (phương thức và khối), nói về các công cụ hiện đại trong java.util.concurrent ( Lock, ReentrantLock, Semaphore, v.v.), xem các ví dụ thực tế với việc tăng bộ đếm và những lỗi thường gặp (tính không nguyên tử của i ++, đối tượng khóa không đúng, các “huyền thoại” về volatile).

Bài giảng thực hành về đa luồng: phân tích cách hoạt động của từ khóa synchronized (khối và phương thức, monitor của đối tượng và khóa ở cấp lớp ClassName.class), sự khác nhau giữa khả năng hiển thị thay đổi qua volatile và tính nguyên tử của các thao tác, vì sao các cờ boolean nên khai báo là volatile, còn phép tăng count ++ thì cần đồng bộ hóa. So sánh khi nào chọn synchronized và khi nào — volatile, đồng thời phân tích các lỗi thường gặp.

So sánh thực tiễn đồng bộ hóa cổ điển bằng synchronized với các primitive linh hoạt hơn trong gói java.util.concurrent.locks: ReentrantLock và ReadWriteLock. Cùng xem cách điều khiển khóa một cách tường minh ( lock()/ unlock(), tryLock() với timeout), cách mở rộng đọc với ReentrantReadWriteLock, “tính công bằng” ( fair mode) là gì, mỗi công cụ phù hợp ở đâu và các lỗi thường gặp.

Trong bài giảng này, chúng ta xem xét các primitive đồng bộ hóa cốt lõi trong Java: cách bảo vệ vùng tới hạn bằng synchronized và lớp ReentrantLock (các phương thức lock()/ unlock(), cấu trúc try- finally), cũng như cách giới hạn mức song song thông qua Semaphore (các phương thức acquire()/ release()). Chúng ta sẽ so sánh mutex và semaphore trong một bảng, xem các tình huống thực tế (ngân hàng, máy chủ có giới hạn kết nối) và các lỗi điển hình dẫn đến deadlock và suy giảm hiệu năng.

Phân tích thực tiễn các lỗi thường gặp của đa luồng trong Java: quên unlock()/ release() với ReentrantLock và Semaphore (khắc phục bằng try- finally), chọn sai monitor cho synchronized, deadlock và thứ tự lấy lock, đồng bộ hóa quá mức, cũng như giới hạn áp dụng của volatile và thay thế bằng AtomicInteger. Ví dụ, lời khuyên và các phép so sánh dễ hiểu — để mã không “đứng hình”.