线程状态切换代码小记

小小明童鞋

发布于 2020-05-11 09:12:33

7400

发布于 2020-05-11 09:12:33

文章被收录于专栏：java系列博客java系列博客

《java并发编程》那本书其实反复的看过很多遍了，也扒了很多多线程相关文章，但是不用的话很快就又忘记了，想到一个概念于是动手操作了一遍，以便加深认知。

先看一下Thread类的源码中线程状态的枚举说明，共有六种线程状态。

` /** * A thread state. A thread can be in one of the following states: * <ul>

 * <li>{[@link](https://my.oschina.net/u/393) #NEW}<br>
 *     A thread that has not yet started is in this state.
      一个线程在创建对象后，以及调用start()之前，状态为new
 *     </li>
 
 * <li>{[@link](https://my.oschina.net/u/393) #RUNNABLE}<br>
 *     A thread executing in the Java virtual machine is in this state.
       线程在虚拟机中执行，进入RUNABLE状态（又细分为READY（就绪）-中间等待分配时间片段-以及RUNNING（运行中））
 *     </li>
 
 * <li>{[@link](https://my.oschina.net/u/393) #BLOCKED}<br>
 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
      一个线程在等待获取监视器锁的时候进入线程阻塞状态，即排队获取锁的状态。
 *     </li>
 
 * <li>{[@link](https://my.oschina.net/u/393) #WAITING}<br>
 *     A thread that is waiting indefinitely for another thread to
 *     perform a particular action is in this state.
       等待其它线程唤醒时处于等待状态。
 *     </li>
 
 * <li>{[@link](https://my.oschina.net/u/393) #TIMED_WAITING}<br>
 *     A thread that is waiting for another thread to perform an action
 *     for up to a specified waiting time is in this state.
       在一定时间里等待其它线程唤醒，超过时间唤醒线程重新获取锁。
 *     </li>
 
 * <li>{@link #TERMINATED}<br>
 *     A thread that has exited is in this state.
       一个线程的结束状态。
 *     </li>
 
 * </ul>
 *
 * <p>
 * A thread can be in only one state at a given point in time.
 * These states are virtual machine states which do not reflect
 * any operating system thread states.
 *
 * @since   1.5
 * @see #getState
 */
 
 
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 （在创建一个线程对象后至调用start()之前，线程状态处于NEW），调用start()之后进入RUNABLE，线程执行结束进入BLOCKD状态

`package com.example.demo.thread;

/**

线程状态转换演示 NEW RUNABLE */ public class ThreadNewRunable extends Thread { private byte[] lock = new byte[0]; public ThreadNewRunable(byte[] lock) { this.lock = lock; } @Override public void run() { // doNothing

// synchronized (lock) { // try { // Thread.sleep(1000);// 休眠十秒，防止过快结束 // } catch (InterruptedException e) { // e.printStackTrace(); // } // } }

public static void main(String[] args) throws InterruptedException {


    byte[] lock = new byte[0];
    ThreadNewRunable threadNewRunable = new ThreadNewRunable(lock);
    System.out.println("threadStatu-new ：" + threadNewRunable.getState());

    threadNewRunable.start();
    System.out.println("threadStatus-start：" + threadNewRunable.getState());

    ThreadNewRunable threadNewRunable1 = new ThreadNewRunable(lock);
    threadNewRunable1.start();


    Thread.sleep(1000);

    System.out.println("threadStatu1-blocked : " + threadNewRunable1.getState());
}

}

输出结果

threadStatu-new ：NEW threadStatus-start：RUNNABLE threadStatu1-blocked : TERMINATED

BLOCKED 在线程等待获取锁，synchronized块或者synchronized方法时，线程进入阻塞状态

`package com.example.demo.thread;

public class ThreadBlocked extends Thread {

private byte[] lock = new byte[0];

public ThreadBlocked(byte[] lock) {
    this.lock = lock;
}

@Override
public void run() {

    synchronized (lock) {
        try {
            Thread.sleep(10000);// 休眠十秒，防止过快结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadBlocked threadBlocked = new ThreadBlocked(lock);
    threadBlocked.start();
    ThreadBlocked threadBlocked1 = new ThreadBlocked(lock);
    threadBlocked1.start();
    Thread.sleep(1000);
    System.out.println("threadBlocked1-blocked : " + threadBlocked1.getState());
}

}

输出

threadBlocked1-blocked : BLOCKED

WAITING （当执行 Object.wait(); Thread.join(); LockSupport.park();时，线程计入等待状态）
Object.wait()

`package com.example.demo.thread;

public class ThreadWaitingObjectWait extends Thread {

private byte[] lock = new byte[0];

public ThreadWaitingObjectWait(byte[] lock) {
    this.lock = lock;
}

@Override
public void run() {

    synchronized (lock) {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadWaitingObjectWait waitingObjectWait = new ThreadWaitingObjectWait(lock);
    waitingObjectWait.start();
    Thread.sleep(100);

    System.out.println("waitingObjectWait wait.start(): " + waitingObjectWait.getState());

    synchronized (lock) {
        lock.notify();
    }
    Thread.sleep(100);
    System.out.println("waitingObjectWait lock.notify() :" + waitingObjectWait.getState());
}

} `

输出

waitingObjectWait wait.start(): WAITING waitingObjectWait lock.notify() :TERMINATED

LockSupport.park()

`package com.example.demo.thread;

import java.util.concurrent.locks.LockSupport;

public class ThreadWaitingPark extends Thread {

private byte[] lock = new byte[0];

public ThreadWaitingPark(byte[] lock) {
    this.lock = lock;
}

@Override
public void run() {

        // 以下三种均可使线程进入waiting状态

// Object.wait(); // Thread.join();; LockSupport.park();

}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadWaitingPark threadWaitingPark = new ThreadWaitingPark(lock);
    threadWaitingPark.start();
    Thread.sleep(1000);
    System.out.println("threadWaiting-Waiting-when LockSupport.park() : " + threadWaitingPark.getState());
    LockSupport.unpark(threadWaitingPark);
    Thread.sleep(1000);
    System.out.println("threadWaiting-Waiting-when LockSupport.unpark(thread)  : " + threadWaitingPark.getState());


}

} `

输出

threadWaiting-Waiting-when LockSupport.park() : WAITING threadWaiting-Waiting-when LockSupport.unpark(thread) : TERMINATED

Thread.join()

`package com.example.demo.thread;

import org.jetbrains.annotations.NotNull;

public class ThreadWaitingThreadJoin extends Thread {

private Thread thread = new Thread();

public ThreadWaitingThreadJoin(Thread thread) {
    this.thread = thread;
}

@Override
public void run() {
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadNewRunable threadNewRunable = new ThreadNewRunable(lock);
    threadNewRunable.start();
    ThreadWaitingThreadJoin threadWaitingThreadJoin = new ThreadWaitingThreadJoin(threadNewRunable);
    threadWaitingThreadJoin.start();
    Thread.sleep(100);
    System.out.println("threadWaitingThreadJoin.join() : " + threadWaitingThreadJoin.getState());
}

} `

输出

threadWaitingThreadJoin.join() : TERMINATED

TIMEDWAITING （WAITING等待只要没有线程唤醒，它就一直等待下去，而TIMEDWAITING则会在超出等待时间后唤醒线程去获取锁）

当执行 Thread.sleep(long); Object.wait(long); Thread.join(long); LockSupport.parkNanos(); LockSupport.parkUntil(); 时线程会进入延时等待状态。

Thread.sleep(long)

`package com.example.demo.thread;

public class ThreadTimedWaitingThreadSleep extends Thread {

private byte[] lock = new byte[0];

public ThreadTimedWaitingThreadSleep(byte[] lock) {
    this.lock = lock;
}

@Override
public void run() {
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadTimedWaitingThreadSleep timedWaitingThreadSleep = new ThreadTimedWaitingThreadSleep(lock);
    timedWaitingThreadSleep.start();
    Thread.sleep(100);
    System.out.println("timedWaitingThreadSleep Thread.sleep(long) : " + timedWaitingThreadSleep.getState());
}

} `

输出

timedWaitingThreadSleep Thread.sleep(long) : TIMED_WAITING

Object.wait(long)

`package com.example.demo.thread;

public class ThreadTimedWaitingObjectWait extends Thread { private byte[] lock = new byte[0];

public ThreadTimedWaitingObjectWait(byte[] lock) {
    this.lock = lock;
}

@Override
public void run() {


    synchronized (lock) {
        // 其它使线程进入timedWaiting
        // Thread.join(long)
        //LockSupport.parkNanos()
        //LockSupport.parkUntil()
        try {
            lock.wait(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    byte[] lock = new byte[0];
    ThreadTimedWaitingObjectWait timedWaitingObjectWait = new ThreadTimedWaitingObjectWait(lock);
    timedWaitingObjectWait.start();
    Thread.sleep(100);

    System.out.println("timedWaitingObjectWait wait.start(): " + timedWaitingObjectWait.getState());

    Thread.sleep(2000);
    System.out.println("timedWaitingObjectWait after sleep(20000) :" + timedWaitingObjectWait.getState());
}

} `