Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

ConcurrencyJunior16 phút đọc

Thread trong Java: tạo thread, vòng đời và interrupt

Ôn 10 thẻ
Trong bài này

Cụm bài Thread và concurrency trong Java: 1. Tạo thread và vòng đời · 2. Race condition, volatile, deadlock · 3. ExecutorService và virtual thread

Tomcat, HikariCP, @Scheduled, Kafka consumer đều chạy trên thread; khi số đếm lệch, app treo hay người A thấy dữ liệu của người B, người hiểu thread mới tìm ra nguyên nhân. Đọc xong, bạn tạo được thread bằng Thread/Runnable/Callable, đọc được sáu trạng thái và dừng thread đúng cách bằng interrupt. Cần biết Java cơ bản và exception; phần 2 nói về race condition, volatile, deadlock, phần 3 về thread pool, virtual thread, ThreadLocal (demo chạy trên JDK 21).

1. Process, thread, concurrency và parallelism

Ý chính: process là chương trình đang chạy với bộ nhớ riêng; thread là luồng thực thi bên trong process, chung heap, và là đơn vị hệ điều hành lập lịch lên CPU.

Mỗi thread có stack riêng (biến local, frame của method) và program counter riêng. Cách OS quản lý process, thread và context switch (chuyển CPU từ thread này sang thread khác): xem Hệ điều hành cho backend: kernel, system call, process và thread.

Process Thread
Bộ nhớ Riêng, tách biệt Chung heap, stack riêng
Chi phí tạo Lớn (fork, bảng trang mới) Nhỏ hơn nhiều, nhưng vẫn ~1 MB stack + một OS thread
Giao tiếp IPC: socket, pipe, file Đọc/ghi chung object trên heap
Một cái chết Process khác không sao Exception chưa bắt chỉ giết thread đó, nhưng dữ liệu chung bị hỏng thì cả process chịu

Ví dụ “vừa nghe nhạc, vừa lướt web, vừa tải file” thật ra là ba process. Ví dụ đúng cho thread: trong một JVM, mỗi request HTTP do một thread của Tomcat xử lý.

  • Concurrency (đồng thời): nhiều việc đang dở dang cùng lúc, có thể xen kẽ trên một core. Là chuyện cấu trúc.
  • Parallelism (song song): nhiều việc thực sự chạy cùng thời điểm trên nhiều core. Là chuyện thực thi.

Server 2 core phục vụ 200 request cùng lúc: concurrency cao, parallelism tối đa là 2.

Khi nào thread giúp được

  • I/O bound (gọi DB, HTTP, đọc file): thread chủ yếu ngồi chờ, nhiều thread giữ CPU không rảnh. Trường hợp phổ biến nhất ở backend.
  • CPU bound (nén ảnh, mã hoá): thread luôn bận; thêm thread quá số core không nhanh hơn, chỉ tốn context switch.
  • Giữ phản hồi: tách việc chậm (gửi email, xuất báo cáo) khỏi thread phải luôn rảnh, như thread xử lý request hay event loop của Netty.

Cái giá: race condition (dữ liệu chung bị tranh chấp), deadlock (chờ nhau mãi), lỗi khó tái hiện vì phụ thuộc thời điểm; phần 2 xoay quanh ba thứ đó.

Thêm ví dụ thread và các thread có sẵn trong JVM
  • Ví dụ thread trong trình duyệt: trong một trình duyệt, một thread vẽ giao diện, một thread tải ảnh, một thread chạy JavaScript.
  • Giữ phản hồi ngoài backend: thread giao diện của app desktop/Android phải luôn rảnh, nên việc chậm chạy ở thread khác.
  • Mỗi chương trình Java khởi động với ít nhất thread main chạy method main, kèm vài thread nền của JVM (GC, JIT compiler, Finalizer, Signal Dispatcher).

2. Tạo thread: Thread, Runnable, Callable

Ý chính: tách “việc cần làm” (Runnable, hoặc Callable nếu cần kết quả) khỏi “người làm” (Thread hay executor), và chỉ start() mới thật sự tạo thread mới.

extends Thread và implements Runnable

// Cách 1: kế thừa Thread
class ReportThread extends Thread {
    @Override
    public void run() {
        System.out.println("building report on " + getName());
    }
}

// Cách 2: tách "việc cần làm" (Runnable) khỏi "người làm" (Thread)
Runnable sendEmail = () -> System.out.println("sending on " + Thread.currentThread().getName());

new ReportThread().start();
new Thread(sendEmail, "mailer").start();

Runnable là functional interface chỉ có void run(), nên viết bằng lambda được.

Hai thread chạy xen kẽ

Các bước: class implements Runnable, override run(), truyền object vào constructor của Thread, gọi start(). Demo bên dưới cho thấy:

  • main in dòng của nó trước cả hai thread, vì start() trả về ngay, không chờ run() xong.
  • Thứ tự giữa hai thread do bộ lập lịch của OS quyết định (resize 3 in trước download 3 dù download start trước). Đừng dựa vào nó; muốn chờ thì dùng join() (mục 4).
Demo hai thread đếm ngược xen kẽ và output

Hai việc đếm ngược trên hai thread, mỗi vòng nghỉ bằng Thread.sleep để thấy chúng xen kẽ:

public class Interleave {
    static class Countdown implements Runnable {
        private final String label;
        private final long pauseMs;

        Countdown(String label, long pauseMs) {
            this.label = label;
            this.pauseMs = pauseMs;
        }

        @Override
        public void run() {
            for (int i = 3; i >= 1; i--) {
                System.out.println(label + " " + i + " on " + Thread.currentThread().getName());
                try {
                    Thread.sleep(pauseMs);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread download = new Thread(new Countdown("download", 100), "t-download");
        Thread resize = new Thread(new Countdown("resize", 150), "t-resize");
        download.start();
        resize.start();
        System.out.println("main keeps going on " + Thread.currentThread().getName());
        download.join();
        resize.join();
        System.out.println("both done");
    }
}

Một lần chạy:

main keeps going on main
resize 3 on t-resize
download 3 on t-download
download 2 on t-download
resize 2 on t-resize
download 1 on t-download
resize 1 on t-resize
both done

Callable và Future: khi cần kết quả

Runnable.run() không trả giá trị, không ném checked exception. Callable<V>.call() trả V và được throws Exception. Callable không truyền thẳng vào new Thread(...) được; đưa cho ExecutorService (phần 3) để nhận Future<V>:

import java.util.concurrent.*;

public class CallableDemo {
    public static void main(String[] args) throws InterruptedException {
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            Callable<Integer> priceLookup = () -> {
                Thread.sleep(200);              // giả lập gọi API
                return 42_000;
            };
            Future<Integer> price = pool.submit(priceLookup);
            Future<Integer> broken = pool.submit(() -> {
                throw new IllegalStateException("upstream down");
            });

            try {
                System.out.println("price = " + price.get(1, TimeUnit.SECONDS));
                broken.get();
            } catch (ExecutionException e) {
                System.out.println("task failed: " + e.getCause());
            } catch (TimeoutException e) {
                price.cancel(true);
                System.out.println("too slow, cancelled");
            }
        }
    }
}
// price = 42000
// task failed: java.lang.IllegalStateException: upstream down
  • get() chặn tới khi có kết quả; ở production luôn dùng bản có timeout.
  • Lỗi trong task được gói vào ExecutionException, lỗi gốc ở getCause().
  • cancel(true) interrupt thread đang chạy task (chỉ dừng thật nếu task tôn trọng interrupt, mục 4).
  • Ghép nhiều bước bất đồng bộ thì dùng CompletableFuture; Future thuần chỉ có get() chặn.

start() và run()

public class StartVsRun {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> System.out.println("running in: " + Thread.currentThread().getName());

        Thread t = new Thread(task, "worker-1");
        t.run();    // chỉ là một lời gọi method bình thường
        t.start();  // JVM tạo thread mới, thread đó gọi run()
        t.join();

        try {
            t.start(); // lần thứ hai
        } catch (IllegalThreadStateException e) {
            System.out.println("start twice -> " + e.getClass().getSimpleName());
        }
    }
}
// running in: main
// running in: worker-1
// start twice -> IllegalThreadStateException

3. Vòng đời: 6 trạng thái của thread

Ý chính: Thread.getState() trả một trong 6 giá trị; điểm hay bị hỏi là không có RUNNING, I/O vẫn là RUNNABLE, và BLOCKED chỉ dành cho synchronized.

Trạng thái Nghĩa Vào bằng cách nào
NEW Đã tạo object, chưa start() new Thread(...)
RUNNABLE Đang chạy hoặc sẵn sàng chạy, chờ OS cấp CPU start()
BLOCKED Chờ vào một khối synchronized mà thread khác đang giữ monitor synchronized bị tranh chấp
WAITING Chờ không thời hạn đến khi thread khác đánh thức wait(), join(), LockSupport.park() (cũng là cách ReentrantLock.lock() chờ)
TIMED_WAITING Như WAITING nhưng có hạn sleep(ms), wait(ms), join(ms), parkNanos
TERMINATED run() đã kết thúc (bình thường hoặc do exception) Hết run()
stateDiagram-v2
  [*] --> NEW
  NEW --> RUNNABLE: start
  RUNNABLE --> BLOCKED: vào synchronized đang bị giữ
  BLOCKED --> RUNNABLE: lấy được monitor
  RUNNABLE --> WAITING: wait / join / park
  WAITING --> RUNNABLE: notify / thread kia kết thúc / unpark
  RUNNABLE --> TIMED_WAITING: sleep / wait có timeout / join có timeout
  TIMED_WAITING --> RUNNABLE: hết giờ / được đánh thức
  RUNNABLE --> TERMINATED: run kết thúc
  TERMINATED --> [*]
  • Java không có trạng thái “RUNNING” riêng: đang chạy trên CPU hay xếp hàng chờ CPU đều là RUNNABLE.
  • Thread chặn trên I/O (đọc socket, file) vẫn báo RUNNABLE, vì với JVM nó đang ở native code. Xem thread dump đừng nghĩ “RUNNABLE = đang đốt CPU”.
  • BLOCKED chỉ dành cho synchronized. Thread chờ ReentrantLock hiện WAITING (lock dùng LockSupport.park).
Demo tạo đủ cả 6 trạng thái và bẫy đọc trạng thái
public class ThreadStates {
    private static final Object LOCK = new Object();

    public static void main(String[] args) throws Exception {
        Thread sleeper = new Thread(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        System.out.println("1. " + sleeper.getState());          // NEW
        sleeper.start();
        Thread.sleep(100);
        System.out.println("2. " + sleeper.getState());          // TIMED_WAITING

        Thread blocked = new Thread(() -> {
            synchronized (LOCK) { /* cần LOCK mà main đang giữ */ }
        });
        Thread waiter = new Thread(() -> {
            try {
                sleeper.join();                                    // chờ không giới hạn
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        synchronized (LOCK) {
            blocked.start();
            waiter.start();
            Thread.sleep(100);
            System.out.println("3. " + blocked.getState());      // BLOCKED
            System.out.println("4. " + waiter.getState());       // WAITING
        }

        Thread spinner = new Thread(() -> {
            long end = System.nanoTime() + 300_000_000L;
            while (System.nanoTime() < end) { /* bận tính toán */ }
        });
        spinner.start();
        Thread.sleep(50);
        System.out.println("5. " + spinner.getState());          // RUNNABLE

        sleeper.join();
        waiter.join();
        blocked.join();
        spinner.join();
        System.out.println("6. " + sleeper.getState());          // TERMINATED
    }
}

4. Điều khiển thread: sleep, join, interrupt

Ý chính: sleep tạm dừng thread hiện tại, join chờ thread khác xong; muốn dừng một thread thì chỉ có interrupt(), và thread kia phải tự hợp tác.

  • Thread.sleep(ms): không nhả lock đang giữ.
  • t.join() / t.join(ms): ngoài việc chờ, còn bảo đảm mọi thứ t đã ghi đều nhìn thấy được sau khi join trả về (happens-before, xem phần 2).
  • obj.wait() / obj.notifyAll(): chờ/đánh thức cấp thấp, phải giữ monitor của obj; wait() nhả monitor khi chờ. Code mới dùng BlockingQueue, CountDownLatch, CompletableFuture.

Interrupt: cách duy nhất để dừng thread một cách lịch sự

Java không có cách an toàn để “giết” thread: Thread.stop() đã bị khoá hẳn vì có thể bỏ dở giữa chừng và làm hỏng dữ liệu. Thay vào đó là hợp tác: A gọi b.interrupt() để bật cờ interrupt của B; B tự kiểm tra cờ và tự dừng.

B đang làm gì Chuyện gì xảy ra
Chặn trong sleep, wait, join, BlockingQueue.take/poll… Method ném InterruptedException và xoá cờ
Đang tính toán Không gì cả, tới khi B tự kiểm tra Thread.currentThread().isInterrupted()
I/O cổ điển trên socket (InputStream.read) Không phản ứng; phải đóng socket hoặc đặt timeout

Mẫu worker làm đúng:

import java.util.concurrent.*;

public class Interruption {
    static void pollQueue(BlockingQueue<String> queue) {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                String job = queue.poll(1, TimeUnit.SECONDS);
                if (job != null) System.out.println("processing " + job);
            } catch (InterruptedException e) {
                // sleep/poll/wait xoá cờ interrupt khi ném exception -> bật lại
                Thread.currentThread().interrupt();
                System.out.println("interrupted, cleaning up");
            }
        }
        System.out.println("worker exits, flag = " + Thread.currentThread().isInterrupted());
    }

    public static void main(String[] args) throws Exception {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();
        Thread worker = new Thread(() -> pollQueue(queue), "poller");
        worker.start();
        queue.put("job-1");
        Thread.sleep(200);
        worker.interrupt();
        worker.join(2000);
        System.out.println("worker state = " + worker.getState());
    }
}
// processing job-1
// interrupted, cleaning up
// worker exits, flag = true
// worker state = TERMINATED

Bài tập

Bài 1: Đoán output và trạng thái

Đề (diễn đạt lại): cho một đoạn code tạo thread, gọi run(), rồi start(), rồi start() lần nữa sau join(); in tên thread trong task và trạng thái thread ở từng bước. Đoán output.

Lời giải Bài 1

Chính là demo StartVsRun ở mục 2. run() in main; start() in worker-1; start() lần hai ném IllegalThreadStateException vì thread đã TERMINATED và một Thread chỉ start được một lần. Trạng thái: trước start() là NEW, sau join() là TERMINATED; ngay sau start() thì không đoán chắc được (xem pitfall ở mục 3).

Ghi nhớ

  • Giải thích được process và thread khác nhau ở bộ nhớ, chi phí tạo, cách giao tiếp.
  • Phân biệt được concurrency với parallelism, biết khi nào thêm thread vô ích.
  • Nói được vì sao run() không tạo thread mới và vì sao start() lần hai ném exception.
  • Kể được 6 trạng thái và vì sao thread chờ I/O vẫn là RUNNABLE.
  • Biết hai cách xử lý đúng InterruptedException.

Câu hỏi phỏng vấn

Junior

Process và thread khác nhau thế nào?

Process là chương trình đang chạy với vùng nhớ riêng; thread là luồng thực thi bên trong process, chung heap nhưng có stack riêng.

Thread là đơn vị hệ điều hành lập lịch. Thread rẻ hơn và giao tiếp nhanh hơn (đọc chung object), nhưng vì chung bộ nhớ nên phải đồng bộ cẩn thận.

start() và run() khác nhau thế nào?

start() yêu cầu JVM tạo thread mới rồi gọi run() trên đó; gọi run() trực tiếp chỉ là gọi method trên thread hiện tại.

Gọi run() thì không có gì song song. start() chỉ gọi được một lần cho mỗi object Thread, lần hai ném IllegalThreadStateException.

Runnable và Callable khác nhau thế nào? Vì sao nên dùng thay cho extends Thread?

Callable trả kết quả và được ném checked exception, Runnable thì không; cả hai tách việc cần làm khỏi thread chạy nó.

Callable<V> nộp qua ExecutorService.submit để nhận Future<V>. Vì tách khỏi thread, chúng dùng được với thread pool, virtual thread và không chiếm mất quyền kế thừa class như extends Thread.

Thread trong Java có những trạng thái nào?

Sáu: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; không có RUNNING riêng.

NEW chưa start; RUNNABLE đang chạy hoặc chờ CPU, kể cả chặn trên I/O; BLOCKED chờ vào synchronized; WAITING là wait, join, park không hạn; TIMED_WAITING là sleep và các bản có timeout; TERMINATED đã xong.

Mid

sleep() và wait() khác nhau thế nào?

sleep giữ nguyên lock và gọi ở đâu cũng được; wait phải giữ monitor và nhả monitor trong lúc chờ.

Thread.sleep là static, dừng thread hiện tại. obj.wait() không giữ monitor của obj thì ném IllegalMonitorStateException; nó chờ notify/notifyAll hoặc hết hạn, và phải nằm trong vòng while (!condition) vì có thể bị đánh thức giả (spurious wakeup). Code mới nên dùng BlockingQueue, CountDownLatch, Condition.

Xử lý InterruptedException thế nào cho đúng?

Hoặc ném tiếp, hoặc gọi Thread.currentThread().interrupt() để bật lại cờ rồi dừng việc đang làm.

Method chặn đã xoá cờ khi ném. Nuốt lỗi bằng catch rỗng hoặc chỉ log thì shutdownNow(), Future.cancel(true) không dừng được task.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu trong phỏng vấn
thread /θrɛd/ luồng thực thi “Each incoming request is handled by a thread from Tomcat’s pool.”
concurrency /kənˈkʌrənsi/ tính đồng thời “Concurrency is about structure; parallelism is about execution.”
parallelism /ˈpærəlɛlɪzəm/ tính song song “On a two-core machine, parallelism is capped at two.”
interrupt /ˌɪntəˈrʌpt/ ngắt, yêu cầu dừng “Interruption is cooperative; the task has to check the flag.”
context switch /ˈkɒntɛkst swɪtʃ/ chuyển ngữ cảnh giữa các thread “Adding more threads than cores to CPU-bound work only adds context switches.”
I/O-bound / CPU-bound /ˌaɪˈoʊ baʊnd/ bị giới hạn bởi I/O / bởi CPU “Our workload is I/O-bound, so threads spend most of their time waiting on the database.”
lifecycle /ˈlaɪfˌsaɪkəl/ vòng đời “A thread’s lifecycle goes from NEW through RUNNABLE to TERMINATED.”
blocking call /ˈblɒkɪŋ kɔːl/ lời gọi chặn “Future.get() is a blocking call, so I always pass a timeout.”

Ghi chép dựa trên tài liệu Java Core của Hỏi Dân IT và kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.