java多线程之线程的六种状态

Posted 2023-04-12 小鱼不会骑车

线程的六种状态

• • • (1) NEW(初始状态)
    • (2) TERMINATED(终止状态 / 死亡状态)
    • (3) RUNNABLE(运行时状态)
    • (4) TIMED_WAITING(超时等待状态)
    • (5) WAITING(等待状态)
    • (6) BLOCK(阻塞状态)
    • sleep和wait的区别:

操作系统里的线程自身是有一个状态的,但是java Thread 是对系统线程的封装,把这里的状态又进一步细化了~~

状态	说明
NEW	线程还没有创建,但是线程对象已经创建出来了
TERMINATED	线程结束了,但是线程对象还存在
RUNNABLE	就绪状态,可以细分为两个状态
TIMED_WAITING	指超时等待状态
BLOCK	等待状态
WAITING	表示阻塞时出现的状态

下面将通过代码运行结果来带大家细致了解线程运行的状态.

(1) NEW(初始状态)

 public static void main(String[] args) 
        Thread t = new Thread(()->
            System.out.println("t 线程");
        );
        //获取线程的状态
        System.out.println("当前线程是 " +t.getState() + "状态");
        //调用start(),创建这个线程
        t.start();

    

NEW状态指的是 : 线程在刚刚被new出来的时候,还没有调用start()的状态.

此时可以称这个状态为: (1) 初始状态 (2) 创建状态

运行结果:

(2) TERMINATED(终止状态 / 死亡状态)

public static void main(String[] args) 
        Thread t = new Thread(()->
            System.out.println("t 线程");
        );

        //调用start(),创建这个线程
        t.start();
        try 
            //由于计算机的执行速度是很快的,所以1000ms足够t线程执行完
            Thread.sleep(1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
        //获取线程的状态
        System.out.println("当前线程是 " +t.getState() + "状态");
          t.start();
    

如果一个线程的 run() 方法执行结束 该线程就会死亡,对于已经死亡的线程,无法再使用 start() 方法令其进入就绪.

运行结果:

(3) RUNNABLE(运行时状态)

运行时状态可以细分为两个状态:(1) 正在运行状态RUNNING (2) 就绪状态READY

我们可以这么理解 :

(1) 例如我女朋友下班了,我正在带我女朋友去吃饭,此时就是正在运行状态.
(2)因为我提前下班了,但是我女朋友还没有下班,所以此时我在女朋友公司门口等她,只要她下班我随时可以带她吃饭去,此时我就是就绪状态.

通过代码实现(1) :

    public static void main(String[] args) 
        Thread t = new Thread(()->
            while(true)
                //什么都不打印,防止把下面的打印信息冲走
            
        );

        //调用start(),创建这个线程
        t.start();
        //运行线程时判断此时的状态
        System.out.println("当先线程是 "+t.getState()+"状态");

    

由于此时的 t 线程一直在执行死循环,所以 t 线程的状态是正在运行的~~

运行结果:

(4) TIMED_WAITING(超时等待状态)

可以理解为,具有指定等待时间的,正在等待(阻塞)线程的线程状态,由于调用具有指定等待时间的以下方法之一,线程处于定时等待状态.

具有指定等待时间的方法:

(1) Thread.sleep(参数)指定时间,单位为ms
该方法会让当前线程暂停一段时间，其他线程有机会获得 CPU 时间片。
(2) t.join(参数)
调用 t.join 的线程需要等待线程 t 执行指定时间后,才可以运行,等待的过程中是处于阻塞状态的.
(3) wait(参数) :wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间.超过这个时间之后无需其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒该线程,该线程自己就会唤醒.

代码实现(1)

   public static void main(String[] args) 
     Thread t = new Thread(()->
         try 
         //睡眠1000ms
             Thread.sleep(1000);
             System.out.println("hello t");

          catch (InterruptedException e) 
             e.printStackTrace();
         
     );
        //调用start(),创建这个线程
        t.start();
        
        try 
            //等待1000ms,此时t线程就创建结束,系统自动执行run方法里面的逻辑
            Thread.sleep(1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
         //运行线程时判断此时的状态
        System.out.println("当先线程是 "+t.getState()+"状态");
    

运行结果:

代码实现(2)

   public static void main(String[] args) throws InterruptedException 
        Thread t1 = new Thread(()->
            while (true)
                try 
                    //每500ms打印一次
                    Thread.sleep(500);
                    System.out.println("t1");
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        );
        Thread t2 = new Thread(()->
            try 
                //等待t1线程执行完1000ms
                //t2线程再开始执行
                t1.join(1000);
                System.out.println("t2");
             catch (InterruptedException e) 
                e.printStackTrace();
            
        );
        //创建t1线程
        t1.start();
        //创建t2线程
        t2.start();
        //等待500ms此时两个线程都创建完毕
        Thread.sleep(500);
        System.out.println("当先线程是 "+t2.getState()+"状态");
    

运行结果:

代码实现(3)

public class ThreadDemo8 
	//自己指定的锁对象
    static Object object = new Object();

    public static void main(String[] args) throws InterruptedException 
        Thread t1 = new Thread(()->
        //两个锁对象相同
           synchronized (object)
               for (int i = 0; i < 10; i++) 
                   if(i == 5) 
                       try 
                           object.wait(1000);
                            //虽然过了1000ms,但是还是需要等待t2线程中锁里面的程序执行完
                           // 才可以继续执行锁.(这里是指,仅有两个锁,且锁对象相等的情况)
                        catch (InterruptedException e) 
                           e.printStackTrace();
                       
                   
                   System.out.println(i);
               
           
        );
        Thread t2 = new Thread(()->
         //两个锁对象相同
            synchronized (object)
                for (int i = 0; i <10 ; i++) 
                    try 
                   		 System.out.println("t2");
                        Thread.sleep(100);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                
            
                );
        //t1线程先创建
        t1.start();
        //等待100ms是防止t2先抢到锁
        Thread.sleep(100);
        //创建t2线程
        t2.start();
        //查看当前线程的状态
        System.out.println("当先线程是 "+t1.getState()+"状态");
    

运行结果:

(5) WAITING(等待状态)

处于这种状态的线程不会被CPU分配执行时间，他们要等待的显示被唤醒，否则会处于无限期的等待状态

具有阻塞的方法:

(1)使用 Thread.join() 方法。该方法会让当前线程等待另一个线程终止
(2) 使用 Object.wait() 方法。该方法会让当前线程等待,直到其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒该线程。

我们这里只演示第一种就好~

 public static void main(String[] args) throws InterruptedException 
        Thread t1 = new Thread(()->
            while (true)

            
        );
        Thread t2 = new Thread(()->
            try 
                t1.join();
             catch (InterruptedException e) 
                e.printStackTrace();
            
        ,"猪猪侠");

        //创建这t1线程
        t1.start();
        //等待200ms让t1线程优先创建好
        Thread.sleep(200);
        //创建这t2线程
        t2.start();
        //等待200ms让t2线程优先创建好
        Thread.sleep(200);

        System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
    

运行结果是:

(6) BLOCK(阻塞状态)

阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃cpu的使用权，暂停或停止运行，直到线程进入就绪状态，才有机会获得cpu的青睐从而转入运行状态。

我们可以通俗点理解为~ 等待锁的状态.

例如: t1 和 t2 需要的锁对象相同,如果此时 t1 拿到了锁,当 t2 执行到进入锁的代码的时候, t2 就需要等 t1 释放锁之后才可以拿到这把锁.

我们通过代码演示:

public class ThreadDemo8 

    static Object object = new Object();
    
    public static void main(String[] args) throws InterruptedException 
        
        Thread t1 = new Thread(()->
        //两个锁对象相同
           synchronized (object)
               while (true)

               
           
        );
        Thread t2 = new Thread(()->
        //两个锁对象相同
        //由于先执行的t1所以需要等t1释放锁才可以执行t2
        //此时t2处于阻塞状态
            synchronized (object)
                System.out.println("t2");
            
        ,"猪猪侠");
        
        //创建这t1线程
        t1.start();
        
        //等待200ms让t1线程优先创建好
        Thread.sleep(200);
        
        //创建这t2线程
        t2.start();
        
        //等待200ms让t2线程优先创建好
        Thread.sleep(200);
        //查看t2线程的状态
        System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
    

运行结果:

关于线程状态的关系图:

sleep和wait的区别:

sleep()和wait()方法有什么区别：
　sleep()睡眠时，保持对象锁，仍然占有该锁；
　而wait()睡眠时，释放对象锁。
　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

JUC并发编程 -- 回顾多线程(线程的六种状态 & wait / sleep 的区别)

1. 回顾多线程

---

1.1 线程的六种状态

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;
    }

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态统称为称为“运行”。
3. 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得cpu 时间片后变为运行中状态（running）。
4. 阻塞(BLOCKED)：表线程阻塞于锁。
5. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
6. 超时等待(TIME_WAITING)：该状态不同于WAITING，它可以在指定的时间内自行返回。
7. 终止(TERMINATED)：表示该线程已经执行完毕。

Java线程状态变迁图:

---

1.2 状态详细说明

---

1.2.1 初始状态(NEW)

• 实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

---

1.2.2 就绪状态(RUNNABLE之READY)

---

1.2.3 运行中状态(RUNNABLE之RUNNING)

• 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

---

1.2.4 阻塞状态(BLOCKED)

• 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

---

1.2.5 等待(WAITING)

• 处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

---

1.2.6 超时等待(TIMED_WAITING)

• 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

---

1.2.7 终止状态(TERMINATED)

• 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
• 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

---

1.3 wait / sleep 的区别

来自不同的类:

• 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。
• sleep是Thread的静态方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

有没有释放锁(释放资源):

• 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
• sleep是线程被调用时，占着cpu去睡觉，其他线程不能占用cpu，os(操作系统)认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu。sleep(100L)是占用cpu，线程休眠100毫秒，其他进程不能再占用cpu资源，wait（100L）是进入等待池中等待，交出cpu等系统资源供其他进程使用，在这100毫秒中，该线程可以被其他线程notify，但不同的是其他在等待池中的线程不被notify不会出来，但这个线程在等待100毫秒后会自动进入就绪队列等待系统分配资源，换句话说，sleep（100）在100毫秒后肯定会运行，但wait在100毫秒后还有等待os调用分配资源，所以wait100的停止运行时间是不确定的，但至少是100毫秒。
• 就是说sleep有时间限制的就像闹钟一样到时候就叫了，而wait是无限期的除非用户主动notify。

使用范围不同:

wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

---

---