深入java多线程，多线程状态及转换

妖狐艹你老母 2022-03-11 17:16 411阅读 0赞

### 1、线程状态值 ###

在一个时间点，每个线程有且只有一种状态，反应线程当前的状况。

在Thread类中用枚举定义了线程的6中状态：

/**
         * A thread state.  A thread can be in one of the following states:
         */
        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，RUNNABLE，BLOCKED，WAITING，TIMED\_WAITING，TERMINATED。

<table> 
 <tbody> 
  <tr> 
   <td style="width:136px;">状态</td> 
   <td style="width:200px;">名词</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td style="width:136px;">NEW</td> 
   <td style="width:200px;">new：新建/初始状态</td> 
   <td>新建好了的线程对象，未调用start()启动线程</td> 
  </tr> 
  <tr> 
   <td style="width:136px;">RUNNABLE</td> 
   <td style="width:200px;">runnable：运行状态</td> 
   <td> <p>线程对象调用了start()后，线程处于运行状态。调用start()后由于处理器资源，线程可能不能立即分配到cpu资源开始运行，运行状态又分为<strong>运行中（running）</strong>和<strong>就绪（ready）</strong>两种状态，就绪状态的线程在获得CPU时间片后变为运行中状态。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:136px;">BLOCKED</td> 
   <td style="width:200px;">blocked：阻塞状态</td> 
   <td>线程在进入synchronized关键字修饰的方法或代码块（需要获取锁）时的状态，等待获取到锁的过程。</td> 
  </tr> 
  <tr> 
   <td style="width:136px;">WAITING</td> 
   <td style="width:200px;">waiting：等待状态</td> 
   <td>线程对象调用了wait()后的状态，<strong>释放同步锁，</strong>一直处于等待被显式地唤醒的状态，否则会处于无限期等待的状态。就好比你先去墙角反省，直到我叫你。</td> 
  </tr> 
  <tr> 
   <td style="width:136px;">TIMED_WAITING</td> 
   <td style="width:200px;">timed_waiting：超时等待状态</td> 
   <td>线程调用Thread.sleep(long millis)进入超时等待状态，sleep()方法是Thread类的静态本地native方法，它<strong>不会释放同步锁</strong>，等待指定时长后自动唤醒运行，无需主动去唤醒。</td> 
  </tr> 
  <tr> 
   <td style="width:136px;">TERMINATED</td> 
   <td style="width:200px;">terminated：终止状态</td> 
   <td>当线程的run()方法完成时，或者主线程的main()方法完成时，就处于终止状态。线程终止后不能再复生。通常来说就是代码已经执行完毕。</td> 
  </tr> 
 </tbody> 
</table>

### 2、线程转换 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyODEyNDYyNDA_size_16_color_FFFFFF_t_70][] 线程状态转换图

*  新建线程：有三种方式新建线程对象，分别是继承Thread类重写run()方法，实现Runnable接口重写其run()方法，实现Callable接口且有返回值。
 *  运行状态：运行状态包括就绪状态和运行中状态。就绪状态也称准备状态或者可执行状态。线程对象创建后，调用该线程对象的start()方法，线程为可执行状态，等待获取cup运行资源。在cpu调度资源后开始执行，变为运行中状态。运行中的线程在时间片用完或者调用Thread.yield()方法的情况下会进入就绪状态。Thread.yield()方法翻译为让步，就是说一个线程调用这个方法后，它就会把自己cpu执行的时间让掉，退出cpu运行，再与其他线程共同争取cpu运行资源，并不是让给其他线程，只是让出，再同时一起竞争。
 *  超时等待状态：运行中的线程调用了以下方法会进入超时等待状态：Thread.sleep(long millis)；Object.wait(long)；thread.join(long)。当线程过了等待时长后自动变为运行状态，或者调用Object.notifly()、Object.notiflyAll()方法。thread.join(long)方法为Thread类的非静态方法，线程对象才能调用。thread2.join()为确保thread2执行完，thread2.join(2000)为等待thread2执行2000ms，不管是否执行完毕。
 *  等待状态：处于等待中的线程需主要的去唤醒，否则将一直处于等待状态。运行状态的线程调用了Object.wait()、Thread.join()方法进入等待状态，调用Object.notifly()、Object.notiflyAll()方法唤醒线程，进入运行状态。**超时等待和等待状态一大区别为等待状态的线程不会释放同步资源，超时等待线程会释放同步资源。分别对应的是wait()和sleep(long)方法。**
 *  阻塞状态：当运行的线程遇到了需要取得锁的代码块或者方法，即为synchronized修饰的，在获取不到锁的情况下，线程进入阻塞状态，等待其他线程释放锁，当获取到锁是线程就进入运行状态，可见，线程阻塞在多线程中是比较常见的场景。
 *  终止状态：当线程执行完，走完run方法或者主线程main执行完，线程变为终止状态。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyODEyNDYyNDA_size_16_color_FFFFFF_t_70]: /images/20220311/59e1b470e2484d18a9ec4319eea16a90.png