Java 并发编程面试题——Java 线程状态与线程状态转换

绝地灬酷狼 2023-10-06 23:21 21阅读 0赞

#### 目录 ####

*  1.Java 线程有哪几种状态？
 *  2.能不能反复调用同一个线程的 start()？假如一个线程执行完毕，能否再次调用这个线程的 start()？
 *  3.Java 线程状态之间如何进行转换？

> 参考：  
> 《Java 并发编程的艺术》  
> [《深入浅出多线程》][Link 1]

## 1.Java 线程有哪几种状态？ ##

Java 线程一共有 6 种状态，其枚举类 `State` 在 `Thread` 类中的定义如下：

// Thread.State 源码
    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;
    }

![在这里插入图片描述][fe79a026ac074925a26beb3481308d8c.png]

## 2.能不能反复调用同一个线程的 start()？假如一个线程执行完毕，能否再次调用这个线程的 start()？ ##

（1）先给出问题的答案：**两个都不能！**

（2）具体分析如下，我们先来看看 start() 的源码：

public synchronized void start() {
        
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
    
        boolean started = false;
        try {
        
            start0();
            started = true;
        } finally {
        
            try {
        
                if (!started) {
        
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
        
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

在 start() 内部，这里有⼀个 threadStatus 的变量。如果它不等于 0， 调用 start() 会直接抛出 `IllegalThreadStateException` 异常。然后接着往下看，有⼀个 native 的 start0() 方法。这个方法里并没有对 threadStatus 的处理。不过我们可以通过 debug 的方式再看⼀下：

@Test
    public void testStartMethod() {
        
    	Thread thread = new Thread(() -> {
        });
    	thread.start(); // 第⼀次调⽤
    	thread.start(); // 第⼆次调⽤ 
    }

我是在 start() 方法内部的最开始打的断点，叙述下在我这里打断点看到的结果： 第⼀次调用时 threadStatus 的值是 0。 第⼆次调用时threadStatus 的值不为 0。查看当前线程状态的源码：

// Thread.getState⽅法源码：
        public State getState() {
        
            // get current thread state
            return sun.misc.VM.toThreadState(threadStatus);
        }
        
        // sun.misc.VM 源码：
        public static State toThreadState(int var0) {
        
            if ((var0 & 4) != 0) {
        
                return State.RUNNABLE;
            } else if ((var0 & 1024) != 0) {
        
                return State.BLOCKED;
            } else if ((var0 & 16) != 0) {
        
                return State.WAITING;
            } else if ((var0 & 32) != 0) {
        
                return State.TIMED_WAITING;
            } else if ((var0 & 2) != 0) {
        
                return State.TERMINATED;
            } else {
        
                return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
            }
        }

所以，我们结合上面的源码可以得到这两个问题的结果：**两个问题的答案都是不可行**，在调用一次 start() 之后，threadStatus 的值会改变 (threadStatus !=0)，此时再次调用 start() 方法会抛出 `IllegalThreadStateException` 异常。比如，threadStatus 为 2 代表当前线程状态为 TERMINATED。

## 3.Java 线程状态之间如何进行转换？ ##

**Java 线程状态转换图如下所示**：

![在这里插入图片描述][e81a4389e5fc4b15830c98a2bc92ecb2.png]

> Java 将操作系统中的**运行**和**就绪**两个状态合并称为运行状态。阻塞状态是线程阻塞在进入 synchronized 关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在 java.util.concurrent 包中 Lock 接口的线程状态却是等待状态，因为 java.util.concurrent 包中 Lock 接口对于阻塞的实现均使用了 `LockSupport` 类中的相关方法。

[Link 1]: https://redspider.gitbook.io/concurrent/di-yi-pian-ji-chu-pian/4
[fe79a026ac074925a26beb3481308d8c.png]: https://img-blog.csdnimg.cn/fe79a026ac074925a26beb3481308d8c.png
[e81a4389e5fc4b15830c98a2bc92ecb2.png]: https://img-blog.csdnimg.cn/e81a4389e5fc4b15830c98a2bc92ecb2.png