Khi một chương trình java khởi chạy JVM sẽ tạo 1 thread
gọi là main thread
sẽ được khởi tạo và đây là nơi thực thi chương trình. Ngoài ra chúng ta có thể tạo thêm các thread
khác tùy vào nhu cầu sử dụng. Khi chương trình tạo ra các thread
khác ngoài main thread
thì nhu cầu về đồng bộ hóa là cần thiết để tránh dẫn đến deadlock hoặc thu được các kết quả không mong muốn. Khi sử dụng wait()
, join()
, sleep()
method để đồng bộ hóa có ai đặt câu hỏi rằng thread
lúc này đang ở trạng thái nào không? Trong bài viết này chúng ta sẽ cùng tìm hiểu vòng đời của một thread, các trạng thái mà nó trải qua trước khi chết đi.
Các trạng thái trong vòng đời của thread trong Java
Về cơ bản một thread có các trạng thái sau:
New
– Tạo mớiRunnable
– Đang thực thiBlocked
– Bị chặnWaiting
– Trạng thái chờTimed Waiting
– Trạng thái chờ trong một khoảng thời gian xác địnhTerminated
– Chấm dứt
Sơ đồ các enum
bên trong một Thread
sẽ thể hiện rõ nhất các trạng thái bên trong một vòng đời của Thread
này. Bạn hãy nhìn các state dưới enum
dưới đây

Ngay khi bạn tạo mới một Thread
, nhưng vẫn chưa gọi đến phương thức start()
, trạng thái của nó sẽ là NEW
.
Còn khi bạn đã gọi đến start()
, thread
đó sẽ vào trạng thái RUNNABLE
, trạng thái này đưa Thread
vào hàng đợi để đợi hệ thống cấp tài nguyên và khởi chạy sau đó.
Trong quá trình Thread
đang chạy, nếu có bất kỳ tác động nào, ngoại trừ làm kết thúc vòng đời của Thread
, nó sẽ vào trạng thái BLOCKED
, hoặc WAITING
, hoặc TIMED_WAITING
.
Blocked/Waiting:
- Khi một
thread
ngừng hoạt động tạm thời trong một khoảng thời gian thì nó sẽ nằm 1 trong 2 trạng tháiBlocked
hoặcWaiting
. - Khi một
thread
chờ một tác vụ I/O thực thi hoàn tất, nó đang ở trong trạng tháiBlocked
. Khi đang ở trong trại thái nàythread
sẽ không thể thực thi thêm bất kỳ đoạn mã nào của nó cho đến khi nó được chuyển sang trạng tháiRunnable
. - Các
thread
sẽ bị chặn khi cố truy cập vào một đoạn mã code đang được chiếm bởi mộtthread
khác, lúc này chúng sẽ rơi vào trạng tháiBlocked
. Khi đoạn mã đượcthread
chiếm đóng giải phóng, chương trình sẽ chọn 1 trong số cácthread
chờ để thực thi đoạn mã hoặc do các điều kiện mà chúng ta đưa ra thì chúng ta chuyển sang trạng tháiWaiting
. Khi mộtthread
được chọn để thực thi đoạn mã thì nó sẽ chuyển sang trạng tháiRunnable
.
Timed Waiting: các thread sẽ chuyển sang trạng thái Timed Waiting
khi các method wait()
, join()
được gọi với một khoản thời gian cụ thể. Sau khi hết thời gian chờ chúng sẽ quay trở lại với trạng thái Runnable
.
Một thread
sẽ kết thúc chu trình sống sau khi chúng đã thực thi hết mã bên trong nó hoặc xảy ra một lỗi ngoại lệ nào đó. Sau khi chuyển qua trạng thái Terminated thread
sẽ không còn tiêu tốn tài nguyên của CPU và đợi cho đến khi trình dọn rác dọn dẹp.
Tổng quan là vậy, còn chi tiết từng trạng thái thì chúng ta sẽ tiếp tục đến phầnn tiếpp theo.
Ví dụ vòng đời của Thread trong Java
class thread implements Runnable {
public void run() {
// moving thread2 to timed waiting state
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("State of thread1 while it called join() method on thread2 -" +
Test.thread1.getState());
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Test implements Runnable {
public static Thread thread1;
public static Test obj;
public static void main(String[] args) {
obj = new Test();
thread1 = new Thread(obj);
// thread1 created and is currently in the NEW state.
System.out.println("State of thread1 after creating it - " + thread1.getState());
thread1.start();
// thread1 moved to Runnable state
System.out.println("State of thread1 after calling .start() method on it - " +
thread1.getState());
}
public void run() {
thread myThread = new thread();
Thread thread2 = new Thread(myThread);
// thread1 created and is currently in the NEW state.
System.out.println("State of thread2 after creating it - " + thread2.getState());
thread2.start();
// thread2 moved to Runnable state
System.out.println("State of thread2 after calling .start() method on it - " +
thread2.getState());
// moving thread1 to timed waiting state
try {
//moving thread1 to timed waiting state
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("State of thread2 after calling .sleep() method on it - " +
thread2.getState());
try {
// waiting for thread2 to die
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("State of thread2 when it has finished it's execution - " +
thread2.getState());
}
}
State of thread1 after creating it – NEW
State of thread1 after calling .start() method on it – RUNNABLE
State of thread2 after creating it – NEW
State of thread2 after calling .start() method on it – RUNNABLE
State of thread2 after calling .sleep() method on it – TIMED_WAITING
State of thread1 while it called join() method on thread2 -WAITING
State of thread2 when it has finished it’s execution – TERMINATED