Java Concurrency

📌 Phần 1: `synchronized` – Cơ chế đồng bộ cơ bản

1️⃣ `synchronized` là gì?

synchronized đảm bảo rằng chỉ một thread có thể truy cập vào một đoạn code cụ thể tại một thời điểm.
Java cung cấp ba cách sử dụng synchronized:
1. Synchronized method
2. Synchronized block
3. Synchronized static method

2️⃣ Ví dụ: synchronized method

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Kết quả luôn là 2000
    }
}

👉 Giải thích: synchronized đảm bảo chỉ một thread có thể gọi increment() cùng một lúc.

3️⃣ `synchronized` block – Đồng bộ hóa chỉ một phần code

class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) { // Chỉ đồng bộ hóa khối này
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

👉 Ưu điểm: Hạn chế phạm vi đồng bộ hóa giúp tăng hiệu suất vì không khóa toàn bộ phương thức.

4️⃣ synchronized trên static method

class StaticCounter {
    private static int count = 0;

    public static synchronized void increment() { // Khóa ở cấp class
        count++;
    }

    public static int getCount() {
        return count;
    }
}

👉 Static method synchronized khóa ở cấp Class, thay vì instance

📌 Phần 2: Locks – Kiểm soát đồng bộ nâng cao

1️⃣ `Lock` vs `synchronized`

synchronized

Lock (ReentrantLock)

Dễ sử dụng

Cung cấp kiểm soát chi tiết hơn

Tự động giải phóng

Phải unlock() thủ công

Không thể kiểm tra nếu một thread có lock

Có thể kiểm tra trạng thái lock

2️⃣ Ví dụ: ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // Luôn giải phóng lock
        }
    }

    public int getCount() {
        return count;
    }
}

public class LockExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

👉 Giải thích: ReentrantLock giúp kiểm soát lock chi tiết hơn synchronized, nhưng bạn phải unlock() thủ công.

3️⃣ tryLock() – Tránh deadlock

if (lock.tryLock()) { 
    try {
        // Thực hiện công việc
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("Không thể lấy lock, thử lại sau");
}

👉 Tránh chờ vô hạn nếu lock không khả dụng.

📌 Phần 3: Atomic Variables – Giải pháp tối ưu cho biến dùng chung

1️⃣ `AtomicInteger` – Thay thế `synchronized`

Nếu chỉ cần cập nhật giá trị đơn giản (tăng, giảm, cập nhật), AtomicInteger nhanh hơn synchronized hoặc Lock.

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Thread-safe
    }

    public int getCount() {
        return count.get();
    }
}

public class AtomicExample {
    public static void main(String[] args) throws InterruptedException {
        AtomicCounter counter = new AtomicCounter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Luôn đúng
    }
}

👉 Nhanh hơn synchronized vì không cần lock, dùng CPU cache & compare-and-swap (CAS).

📌 Phần 4: ForkJoinPool – Xử lý song song mạnh mẽ

1️⃣ ForkJoinPool là gì?

ForkJoinPool là ThreadPool tối ưu hóa cho tác vụ đệ quy (divide and conquer).
Dùng ForkJoinTask để chia nhỏ công việc thành nhiều task con và xử lý song song.

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask<Integer> {
    private int start, end;
    private static final int THRESHOLD = 5;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i <= end; i++) sum += i;
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(start, mid);
            SumTask rightTask = new SumTask(mid + 1, end);

            leftTask.fork();  // Chạy song song
            return rightTask.compute() + leftTask.join(); // Hợp nhất kết quả
        }
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(1, 20);
        int result = pool.invoke(task);
        System.out.println("Sum: " + result);
    }
}

👉 ForkJoinPool tự động chia nhỏ công việc, tận dụng CPU đa luồng hiệu quả hơn.

🚀 Tổng Kết

✅ Bạn đã học được gì?

🔹 synchronized: Đồng bộ hóa cơ bản, dễ dùng nhưng có thể làm giảm hiệu suất. 🔹 Lock (ReentrantLock): Kiểm soát tốt hơn, tránh deadlock với tryLock(). 🔹 AtomicInteger: Cách tối ưu để cập nhật biến đơn giản mà không cần lock. 🔹 ForkJoinPool: Mô hình xử lý song song mạnh mẽ với thuật toán chia để trị.

1️⃣ Bảng So Sánh Tổng Quan

Tiêu chí

synchronized

ReentrantLock

AtomicInteger

ForkJoinPool

Loại cơ chế

Đồng bộ hóa

Khóa linh hoạt

Biến nguyên tử

Xử lý song song

Cơ chế hoạt động

Chặn thread khác truy cập

Chặn thread khác, hỗ trợ thử lock

Sử dụng Compare-And-Swap (CAS)

Chia nhỏ task và thực thi song song

Hiệu suất

Thấp khi có nhiều thread tranh chấp

Tốt hơn synchronized nhờ kiểm soát chi tiết

Tốt nhất cho biến đơn giản

Tối ưu cho công việc lớn cần song song

Tính năng nâng cao

Không có

Hỗ trợ tryLock(), lockInterruptibly()

Hỗ trợ update không cần lock

Hỗ trợ tự động chia nhỏ task

Xử lý deadlock

Dễ bị deadlock nếu không cẩn thận

tryLock() giúp tránh deadlock

Không có deadlock

Không bị deadlock do chia task tự động

Độ phức tạp

Đơn giản

Trung bình

Rất đơn giản

Phức tạp hơn

Ứng dụng phù hợp

Bảo vệ toàn bộ method hoặc block

Cần kiểm soát chi tiết hơn về lock

Khi chỉ cần cập nhật biến đơn giản

Khi xử lý dữ liệu lớn, công việc đệ quy

2️⃣ Khi Nào Nên Sử Dụng Cơ Chế Nào?

🔹 synchronized 👉 Dùng khi cần đơn giản và hiệu suất không phải là vấn đề lớn. 🔹 ReentrantLock 👉 Dùng khi cần kiểm soát chi tiết hơn, như thử lock (tryLock()) hoặc hỗ trợ nhiều điều kiện chờ (Condition). 🔹 AtomicInteger 👉 Dùng khi chỉ cần tăng/giảm biến số nguyên mà không cần lock, tối ưu hiệu suất. 🔹 ForkJoinPool 👉 Dùng khi xử lý công việc lớn có thể chia nhỏ, như thuật toán đệ quy hoặc xử lý song song dữ liệu lớn.

PreviousChapter 7. GarbageCollection NextJava Concurrency 2

Last updated 2 months ago

📌 Phần 1: synchronized – Cơ chế đồng bộ cơ bản

1️⃣ synchronized là gì?

3️⃣ synchronized block – Đồng bộ hóa chỉ một phần code