面试官瞅了瞅我精悍的简历，随口一问，说说Java线程有哪些状态？

这问的也太基础了，这就是开场白吗？

这个简单的呀，面试官让我来告诉你，JDK 的 Thread 源码定义了6个状态: java.lang.Thread.State

• New
  尚未启动的线程的线程状态。
• Runnable
  可运行线程的线程状态，等待CPU调度。
• Blocked
  线程阻塞等待监视器锁定的线程状态。处于synchronized同步代码块或方法中被阻塞。
• Waiting
  等待线程的线程状态。下列不带超时的方式:
  Object.wait、Thread.join、 LockSupport.park
• Timed Waiting
  具有指定等待时间的等待线程的线程状态。下列带超时的方式:
  Thread.sleep、0bject.wait、 Thread.join、 LockSupport.parkNanos、 LockSupport.parkUntil
• Terminated
  终止线程的线程状态。线程正常完成执行或出现异常。

文字说的还不是太清楚了，让我来你画个图就一目了然了：

• Thread状态机
  
• 上面那个图太复杂了看不懂？没问题，看个小学生版：
  
  

1 NEW

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

当调用线程的start()方法，线程也不一定会马上执行，因为Java线程是映射到os的线程执行的，此时可能还需要等os调度，但此时该线程的状态已经为RUNNABLE。

2 RUNNABLE

只是说你有资格运行，调度程序没有挑选到你，你就永远是可运行状态。

2.1条件

• 调用start()
• Thread.sleep(long millis)
  
  一定是当前线程调用此方法，当前线程进入阻塞，不释放对象锁，millis后线程自动苏醒进入可运行态。
  作用：给其它线程执行机会的最佳方式。
• 其他线程join()结束
  当前线程里调用其它线程1的join方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。
• 等待用户输入完毕
• 某个线程拿到对象锁
• 当前线程时间片用完
• Thread.yield()
  
  调用当前线程的yield()
  一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让os再次选择线程。
  作用：让同优先级的线程轮流执行，但并不保证一定会轮流执行。实际无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。
• 锁池里的线程拿到对象锁后，进入可运行状态
• 正在执行的线程

该状态最有争议，注释说它表示线程在JVM层面是执行的，但在os不一定，它举例是CPU，毫无疑问CPU是一个os资源，但这也就意味着在等os其它资源时，线程也会是这个状态。

I/O阻塞算是等os的资源？

3 BLOCKED

• 线程由于等待监视器锁，被阻塞。 处于阻塞态的线程在调用Object.wait之后正在等待监视器锁 进入 同步的块/方法或 再进入 同步的块/方法
  

被挂起，线程因为某原因放弃cpu 时间片，暂时停止运行。

3.1条件

• 当前线程调用Thread.sleep()
• 运行在当前线程里的其它线程调用join()，当前线程进入阻塞态
• 等待用户输入时，当前线程进入阻塞态

3.2 分类

• 等待阻塞
  运行的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)

• 同步阻塞
  运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)

• 其他阻塞
  运行的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。
  当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

线程在阻塞等待monitor lock(监视器锁)
一个线程在进入synchronized修饰的临界区的时候,或者在synchronized临界区中调用Object.wait然后被唤醒重新进入synchronized临界区都对应该态。

结合上面RUNNABLE的分析,也就是I/O阻塞不会进入BLOCKED状态,只有synchronized会导致线程进入该状态

关于BLOCKED状态，注释里只提到一种情况就是进入synchronized声明的临界区时会导致，这好理解，synchronized是JVM自己控制的，所以这个阻塞事件它自己能够知道（对比理解上面的os层面）。

interrupt()是无法唤醒的，只是做个标记。

4 等待

• 等待线程的线程状态。
  

处于等待状态的线程正在等待另一个线程执行特定操作。

例如：

• 一个在对象上调用Object.wait()的线程正在等待另一个线程在该对象上调用Object.notify()或Object.notifyAll() 。这样便可以控制线程的执行顺序。
• Thread.join()的线程正在等待指定的线程终止
• 线程拥有对象锁后进入到相应的代码区后，调用相应的“锁对象”的wait()后产生的一种结果

进入条件

由于调用以下方法之一，线程处于等待状态：

• Object.wait()
• LockSupport.park()
• Thread join( )

它们也是在等待另一个对象事件的发生，也就是描述了等待的意思。

WAIT V.S BLOCKED

• BLOCKED
  JVM认为程序还不能进入某区域，因为同时进去就会有问题，这是一块临界区
• wait()
  先决条件是要进入临界区，即线程已经拿到“凭证”，自己可能进去做了一些事情，但此时通过判定某些业务上的参数，发现还有一些其他配合的资源没有准备充分，那么自己就等等再做其他事

典型案例就是通过wait()/notify()完成生产者/消费者模型。
当生产者生产过快，发现仓库满了，即消费者还没有把东西拿走(空位资源还没准备好) 时，生产者就等待有空位再做事。
消费者拿走东西时会发出“有空位了”的消息，那么生产者就继续工作。
反之，当消费者消费过快发现没有存货时，消费者也会等存货到来，生产者生产出内容后发出“有存货了”的消息，消费者才继续抢东西。

这种状态下，若发生了对该线程的interrupt()是有用的，处于该状态的线程内部会抛InerruptedException，该异常应当在run()里面捕获，使得run()正常执行完成。
在run()内部捕获异常后，还可以让线程继续运行，根据具体场景决定。

这种状态下，若某线程对该锁对象做了notify()，则将从等待池中唤醒一个线程重新恢复到RUNNABLE。
除notify()外，还有一个notifyAll() ，前者是唤醒一个处于WAITING的线程，而后者是唤醒所有的线程。

Object.wait()是否需要死等呢?

不是，除中断外，它还有两个重构方法

• Object.wait(int timeout)
  传入的timeout 参数是超时的毫秒值，超过该值后会自动唤醒，继续做下面的操作(不会抛InterruptedException ，但是并不意味着我们不去捕获，因为不排除其他线程会对它做interrup())
• Object.wait(int timeout,int nanos)
  更精确的超时设置，可以精确到纳秒，这个纳秒值可接受的范围是0~999999 (因为100000onS 等于1ms)。

同样的
LockSupport park( )
LockSupport.parkNanos( )
LockSupport.parkUntil( )
Thread.join()
这些方法都会有类似的重构方法来设置超时，达到类似的目的，不过此时的状态不再是WAITING,而是TIMED.WAITING。

通常写代码的人肯定不想让程序死掉，但是又希望通过这些等待、通知的方式来实现某些平衡，这样就不得不去尝试采用“超时+重试+失败告知”等方式来达到目的。

TIMED_WAITING

当调用Thread.sleep()时,相当于使用某个时间资源作为锁对象，进而达到等待的目的，当时间达到时触发线程回到工作状态。

进入条件

• LockSupport parkNanos(long nanos)
• LockSupport parkUntil(long deadline)

这个线程对象也许是活的，但是，它已经不是一个单独执行的线程，在一个死去的线程上调用start()方法，会抛java.lang.IllegalThreadStateException。

线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。
run()走完了，线程就处于这种状态。其实这只是Java 语言级别的一种状态，在操作系统内部可能已经注销了相应的线程，或者将它复用给其他需要使用线程的请求，而在Java语言级别只是通过Java 代码看到的线程状态而已。

为什么wait( )和notify( )必须要使用synchronized

如果不用就会报ilegalMonitorStateException，常见写法如下:

synchronized(Object){
	object.wait() ;//object.notify() ;
}

synchronized(this){
	this.wait();
}
synchronized fun( ){
	this.wait();//this.notify();
}

while(true) {
	if (Thread.currentThread.isInterrupt()) {
	//可做类似的break、return,抛出InterruptedException 达到某种目的，这完全由自己决定
	//如拋出异常，通常包装一层try catch 异常处理，进一步做处理，如退出run或什么也不做
	}
}