Java线程的6种状态

短命女 2022-02-20 14:31 366阅读 0赞

[线程的概念][Link 1]，以及[线程的创建方式][Link 2]，见我之前写的博文

本篇文章主要讲Java线程的6种状态

6种状态：初始状态（new） 、可运行状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、死亡状态（Dead）、等待队列

**初始状态（New）**：  
进程刚创建，未调用new Thread().start()方法时的状态，[进程创建方式][Link 2]

**可运行状态（Runnable）**：  
在创建线程并调用start()方法之后，获得CPU运行时间之前的状态

进入Runnable状态的方式：

1.  调用线程的start()方法
2.  当前线程sleep()方法结束
3.  其他线程join()结束
4.  等待用户输入完毕（阻塞式IO，拿到IO结果后）
5.  当前线程拿到所需锁
6.  当前线程时间片耗尽
7.  调用当前线程的yield()方法

**运行中状态Running**  
获得CPU运行时间后，运行中的状态

进入Running状态的方式（唯一）：

1.  操作系统的线程调度程序，从可运行状态的线程池中，选出当前线程去执行；

**阻塞状态Blocked**  
运行中的线程，可以会由于各种原因进入到阻塞状态。如调用sleep()方法让线程睡眠，调用wait()方法让线程等待，调用join()、suspend()方法（已弃用）或者阻塞式IO。

进入阻塞状态的方式：

1.  当前线程调用sleep()方法
2.  当前线程执行过程中，调用了其他线程的join()方法，当前线程进入阻塞状态
3.  等待阻塞式IO时

**死亡状态Dead**  
无论是正常退出（run()方法执行完毕），还是抛出了未捕获的异常，都会导致线程进入Dead状态。  
或者是主线程main方法执行完毕  
在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常

**线程的状态流转图**

![线程状态流转图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70]

**线程睡眠：sleep()方法**

线程睡眠，指的是让当前线程暂停执行，等到指定时间后再恢复执行（Runnable状态）

1.  线程睡眠会交出CPU，让给其他线/进程执行
2.  sleep()方法不会释放锁，即当前线程持有某个对象锁时，即使调用sleep()方法其他线程也无法访问这个对象。
3.  调用sleep()，当前线程从Running到blocked，sleep结束，从blocked到Runnable

public static native void sleep(long millis) throws InterruptedException;

**线程让步：yield()方法**

线程让步，指的是让当前线程暂停执行，并执行其他线程  
与sleep()的区别在于

1.  yield()方法无法控制具体交出CPU的时间
2.  yield()方法只能让拥有相同优先级的线程获得CPU执行的机会
3.  yield()方法让当前线程进入Runnable状态

yield()方法：

public static native void yield();

**等待线程终止：join()方法**

等待线程终止，指的是：主线程中调用该方法，就会让调用该方法的线程先执行，等执行结束后，再回到主线程继续执行。（即等待，调用join()方法的线程执行完毕后，再执行）

join()方法：

public final void join() throws InterruptedException { 
    		//join带参数指的是等待的超时时间，为0代表永久等待
            join(0);
        }

**wait()方法**

obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒

public final void wait() throws InterruptedException { }
    
    public final native void wait(long timeout) throws InterruptedException;

**notify()方法**

obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程

public final native void notify();
    
    public final native void notifyAll();

**线程停止的3种方式**

1）：设置标志位，让线程正常停止

class MyThread1 extends Thread { 
    	
    	private boolean flag = false;
    	
    	@Override
    	public void run() { 
    		int i=0;
    		while (!flag) { 
    			System.out.println("线程循环执行次数："+i);
    		}
    	}
    }

2）：使用stop方法强制线程停止，不安全，已废弃！

stop方法：

@Deprecated
        public final void stop() { }

为什么stop()不安全？

因为stop()会解除相应线程持有的所有锁，并且当在线程对象上执行stop方法时，会立即停止该线程

比如当正在执行如下同步方法时，执行到x=10，线程调用了stop()方法，那就会进入不一致的状态，所以线程不安全

public synchronized void f() { 
    	x =10;
    	y =20;
    }

3）：调用interrupt()方法

调用Thread类的interrupted()方法，其本质只是**设置该线程的中断标志**，将中断标志设置为true，并根据线程状态决定是否抛出异常。因此，通过interrupted()方法真正实现线程的中断原理是 ：开发人员根据中断标志的具体值来决定如何退出线程。

interrupt()方法

public void interrupt() { }

**拓展：**

**为什么notify(), wait()等函数定义在Object中，而不是Thread中**

Object中的wait(), notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。

wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！  
OK，线程调用wait()之后，会释放它锁持有的“同步锁”；而且，根据前面的介绍，我们知道：等待线程可以被notify()或notifyAll()唤醒。现在，请思考一个问题：notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？答案是：依据“对象的同步锁”。

负责唤醒等待线程的那个线程(我们称为“唤醒线程”)，它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个)，并且调用notify()或notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，它不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后，等待线程才能获取到“对象的同步锁”进而继续运行。

总之，notify(), wait()依赖于“同步锁”，而“同步锁”是对象锁持有，并且每个对象有且仅有一个！这就是为什么notify(), wait()等函数定义在Object类，而不是Thread类中的原因。

[Link 1]: https://blog.csdn.net/zhaohong_bo/article/details/89221381
[Link 2]: https://blog.csdn.net/zhaohong_bo/article/details/89224545
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70]: /images/20220220/3ffe67e2536643df88a811ddf09489a2.png