線程是JAVA中繞不過(guò)去的一個(gè)話題， 今天本文將會(huì)詳細(xì)講解java中線程的生命周期，希望可以給大家一些啟發(fā)。
java中Thread的狀態(tài)
java中Thread有6種狀態(tài)，分別是：
- NEW - 新創(chuàng)建的Thread，還沒(méi)有開(kāi)始執(zhí)行
- RUNNABLE - 可運(yùn)行狀態(tài)的Thread，包括準(zhǔn)備運(yùn)行和正在運(yùn)行的。
- BLOCKED - 正在等待資源鎖的線程
- WAITING - 正在無(wú)限期等待其他線程來(lái)執(zhí)行某個(gè)特定操作
- TIMED_WAITING - 在一定的時(shí)間內(nèi)等待其他線程來(lái)執(zhí)行某個(gè)特定操作
- TERMINATED - 線程執(zhí)行完畢
我們可以用一個(gè)圖來(lái)直觀的表示：
JDK代碼中的定義如下：
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
NEW
NEW 表示線程創(chuàng)建了，但是還沒(méi)有開(kāi)始執(zhí)行。我們看一個(gè)NEW的例子：
public class NewThread implements Runnable{
public static void main(String[] args) {
Runnable runnable = new NewThread();
Thread t = new Thread(runnable);
log.info(t.getState().toString());
}
@Override
public void run() {
}
}
上面的代碼將會(huì)輸出：
NEW
Runnable
Runnable表示線程正在可執(zhí)行狀態(tài)。包括正在運(yùn)行和準(zhǔn)備運(yùn)行兩種。
為什么這兩種都叫做Runnable呢？我們知道在多任務(wù)環(huán)境中，CPU的個(gè)數(shù)是有限的，所以任務(wù)都是輪循占有CPU來(lái)處理的，JVM中的線程調(diào)度器會(huì)為每個(gè)線程分配特定的執(zhí)行時(shí)間，當(dāng)執(zhí)行時(shí)間結(jié)束后，線程調(diào)度器將會(huì)釋放CPU，以供其他的Runnable線程執(zhí)行。
我們看一個(gè)Runnable的例子：
public class RunnableThread implements Runnable {
@Override
public void run() {
}
public static void main(String[] args) {
Runnable runnable = new RunnableThread();
Thread t = new Thread(runnable);
t.start();
log.info(t.getState().toString());
}
}
上面的代碼將會(huì)輸出：
RUNNABLE
BLOCKED
BLOCKED表示線程正在等待資源鎖，而目前該資源正在被其他線程占有。
我們舉個(gè)例子：
public class BlockThread implements Runnable {
@Override
public void run() {
loopResource();
}
public static synchronized void loopResource() {
while(true) {
//無(wú)限循環(huán)
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new BlockThread());
Thread t2 = new Thread(new BlockThread());
t1.start();
t2.start();
Thread.sleep(1000);
log.info(t1.getState().toString());
log.info(t2.getState().toString());
System.exit(0);
}
}
上面的例子中，由于t1是無(wú)限循環(huán)，將會(huì)一直占有資源鎖，導(dǎo)致t2無(wú)法獲取資源鎖，從而位于BLOCKED狀態(tài)。
我們會(huì)得到如下結(jié)果：
12:40:11.710 [main] INFO com.flydean.BlockThread - RUNNABLE
12:40:11.713 [main] INFO com.flydean.BlockThread - BLOCKED
WAITING
WAITING 狀態(tài)表示線程正在等待其他的線程執(zhí)行特定的操作。有三種方法可以導(dǎo)致線程處于WAITTING狀態(tài)：
- object.wait()
- thread.join()
- LockSupport.park()
其中1，2方法不需要傳入時(shí)間參數(shù)。
我們看下使用的例子：
public class WaitThread implements Runnable{
public static Thread t1;
@Override
public void run() {
Thread t2 = new Thread(()->{
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
log.info("t1"+t1.getState().toString());
});
t2.start();
try {
t2.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
log.info("t2"+t2.getState().toString());
}
public static void main(String[] args) {
t1 = new Thread(new WaitThread());
t1.start();
}
}
在這個(gè)例子中，我們調(diào)用的t2.join()，這會(huì)使調(diào)用它的t1線程處于WAITTING狀態(tài)。
我們看下輸出結(jié)果：
12:44:12.958 [Thread-1] INFO com.flydean.WaitThread - t1 WAITING
12:44:12.964 [Thread-0] INFO com.flydean.WaitThread - t2 TERMINATED
TIMED_WAITING
TIMED_WAITING狀態(tài)表示在一個(gè)有限的時(shí)間內(nèi)等待其他線程執(zhí)行特定的某些操作。
java中有5中方式來(lái)達(dá)到這種狀態(tài)：
- thread.sleep(long millis)
- wait(int timeout) 或者 wait(int timeout, int nanos)
- thread.join(long millis)
- LockSupport.parkNanos
- LockSupport.parkUntil
我們舉個(gè)例子：
public class TimedWaitThread implements Runnable{
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
}
public static void main(String[] args) throws InterruptedException {
TimedWaitThread obj1 = new TimedWaitThread();
Thread t1 = new Thread(obj1);
t1.start();
// The following sleep will give enough time for ThreadScheduler
// to start processing of thread t1
Thread.sleep(1000);
log.info(t1.getState().toString());
}
}
上面的例子中我們調(diào)用了Thread.sleep(5000)來(lái)讓線程處于TIMED_WAITING狀態(tài)。
看下輸出：
12:58:02.706 [main] INFO com.flydean.TimedWaitThread - TIMED_WAITING
那么問(wèn)題來(lái)了，TIMED_WAITING和WAITTING有什么區(qū)別呢？
TIMED_WAITING如果在給定的時(shí)間內(nèi)沒(méi)有等到其他線程的特定操作，則會(huì)被喚醒，從而進(jìn)入爭(zhēng)奪資源鎖的隊(duì)列，如果能夠獲取到鎖，則會(huì)變成Runnable狀態(tài)，如果獲取不到鎖，則會(huì)變成BLOCKED狀態(tài)。
TERMINATED
TERMINATED表示線程已經(jīng)執(zhí)行完畢。我們看下例子：
public class TerminatedThread implements Runnable{
@Override
public void run() {
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new TerminatedThread());
t1.start();
// The following sleep method will give enough time for
// thread t1 to complete
Thread.sleep(1000);
log.info(t1.getState().toString());
}
}
輸出結(jié)果：
13:02:38.868 [main] INFO com.flydean.TerminatedThread - TERMINATED
