Java线程的状态及主要转换方法
操作系统的线程状态
由于线程在现在的操作系统中被视为轻量级进程，所以操作系统中的线程和操作系统中的进程的状态是一致的。
主要有以下三个状态：
- 就绪状态 ready：线程正在等待使用CPU，经过调度程序调用之后可进入running状态。
- 执行状态 running：线程正在使用cpu。
- 等待状态 waiting：线程经过等待时间的调用或者正在等待其它资源。
Java线程的六个状态
Thread源码：
-
NEW：创建了线程，但是此时没有启动，也就是没有调用start方法。
思考：反复的调用某一个线程的start方法是否可行？
如果一个线程已经结束了，那么再继续调用start是否能够再次启动？
答案：两个问题都是不可行的。
通过查看start()的源码就可以看到，该方法中有个变量为threadStatus，只要这个变量的值不为0，就会立马抛出非法状态异常。如果为0才会继续调用后续代码。并且通过debug可以发现，在第二次调用start之后，变量threadStatus的值会改变，比如TERMINATED状态代码为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) { } } } public void testStartMethod() { Thread thread = new Thread(() -> {}); thread.start(); // 第一次调用 thread.start(); // 第二次调用 } // 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; } -
RUNNABLE：表示当前线程正在运行中。处于RUNNABLE状态的线程在Java虚拟机中运行，也有可能在等待CPU分配资源。
Java线程的RUNNABLE状态其实是包括了传统操作系统线程的ready和running两个状态的。
-
BLOCKED：阻塞状态。处于BLOCKED状态的线程正等待锁的释放以进入同步区。
假如今天你下班后准备去食堂吃饭。你来到食堂仅有的一个窗口，发现前面已经有个人在窗口前了，此时你必须得等前面的人从窗口离开才行。
假设你是线程t2，你前面的那个人是线程t1。此时t1占有了锁（食堂唯一的窗口），t2正在等待锁的释放，所以此时t2就处于BLOCKED状态。 -
WAITING：处于等待状态的线程变成RUNNABLE状态需要其他线程唤醒。
调用以下方法会使线程进入等待状态：
-
Object.wait()：使当前线程处于等待状态直到另一个线程唤醒它；
-
Thread.join()：等待线程执行完毕，底层调用的是Object实例的wait方法；
-
LockSupport.park()：除非获得调用许可，否则禁用当前线程进行线程调度。
接着上面的例子，你等了好几分钟现在终于轮到你了，突然你们有一个“不懂事”的经理突然来了。你看到他你就有一种不祥的预感，果然，他是来找你的。
他把你拉到一旁叫你待会儿再吃饭，说他下午要去作报告，赶紧来找你了解一下项目的情况。你心里虽然有一万个不愿意但是你还是从食堂窗口走开了。
此时，假设你还是线程t2，你的经理是线程t1。虽然你此时都占有锁（窗口）了，“不速之客”来了你还是得释放掉锁。此时你t2的状态就是WAITING。然后经理t1获得锁，进入RUNNABLE状态。
要是经理t1不主动唤醒你t2（notify、notifyAll…），可以说你t2只能一直等待了。
-
-
TIMED_WAITING：线程等待一个具体的时间，时间到后会被自动唤醒。
调用如下方法会使线程进入超时等待状态：
- Thread.sleep(long millis)：使当前线程睡眠指定时间；
- Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒；
- Thread.join(long millis)：等待当前线程最多执行millis毫秒，如果millis为0，则会一直执行；
- LockSupport.parkNanos(long nanos)： 除非获得调用许可，否则禁用当前线程进行线程调度指定时间；
- LockSupport.parkUntil(long deadline)：同上，也是禁止线程进行调度指定时间；
到了第二天中午，又到了饭点，你还是到了窗口前。
突然间想起你的同事叫你等他一起，他说让你等他十分钟他改个bug。
好吧，你说那你就等等吧，你就离开了窗口。很快十分钟过去了，你见他还没来，你想都等了这么久了还不来，那你还是先去吃饭好了。
这时你还是线程t1，你改bug的同事是线程t2。t2让t1等待了指定时间，此时t1等待期间就属于TIMED_WATING状态。
t1等待10分钟后，就自动唤醒，拥有了去争夺锁的资格。
-
TERMINATED：终止状态，此时线程已执行完毕。
BLOCKED与RUNNABLE状态的转换
处于BLOCKED状态的线程是因为在等待锁的释放。假如这里有两个线程a和b，a线程提前获得了锁并且暂未释放锁，此时b就处于BLOCKED状态。
public class ThreadPC {
public static void main(String[] args)
{
blockedTest();
}
public static void blockedTest(){
Thread a = new Thread(new Runnable() {
@Override
public void run() {
testMethod();
}
}, "a");
Thread b = new Thread(new Runnable() {
@Override
public void run() {
testMethod();
}
}, "b");
a.start();
b.start();
System.out.println(a.getName() + ":" + a.getState()); // 输出？
System.out.println(b.getName() + ":" + b.getState()); // 输出？
}
// 同步方法争夺锁
private static synchronized void testMethod(){
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
a:RUNNABLE
b:RUNNABLE
并不是想想中的a为TIMED_WAITING，b为BLOCKED
因为除了自定义的这个线程，还有一个main线程在执行，并且start之后执行run需要一定的时间，cpu执行效率高的话，main线程执行较快就两个都是RUNNABLE
稍微修改一下，让其中一个线程能出现BLOCKED状态，就是让主线程等一等，等run方法开始执行。
a.start();
Thread.sleep(1000L);
b.start();
a:TIMED_WAITING
b:RUNNABLE
a.start();
Thread.sleep(1000L);
b.start();
Thread.sleep(3000L);//修改了上面的testMethod方法的睡眠时间，睡久一点，并且让主线程等一等
a:TIMED_WAITING
b:BLOCKED
WAITING状态与RUNNABLE状态的转换
根据转换图我们知道有3个方法可以使线程从RUNNABLE状态转为WAITING状态。我们主要介绍下Object.wait()和Thread.join()。
Object.wait()
调用wait()方法前线程必须持有对象的锁。
线程调用wait()方法时，会释放当前的锁，直到有其他线程调用notify()/notifyAll()方法唤醒等待锁的线程。
需要注意的是，其他线程调用notify()方法只会唤醒单个等待锁的线程，如有有多个线程都在等待这个锁的话不一定会唤醒到之前调用wait()方法的线程。
同样，调用notifyAll()方法唤醒所有等待锁的线程之后，也不一定会马上把时间片分给刚才放弃锁的那个线程，具体要看系统的调度。
Thread.join()
调用join()方法，会一直等待这个线程执行完毕（转换为TERMINATED状态）。
我们再把上面的例子线程启动那里改变一下：
public void blockedTest() {
······
a.start();
a.join();
b.start();
System.out.println(a.getName() + ":" + a.getState()); // 输出 TERMINATED
System.out.println(b.getName() + ":" + b.getState());
}
要是没有调用join方法，main线程不管a线程是否执行完毕都会继续往下走。
a线程启动之后马上调用了join方法，这里main线程就会等到a线程执行完毕，所以这里a线程打印的状态固定是TERMINATED。
至于b线程的状态，有可能打印RUNNABLE（尚未进入同步方法），也有可能打印TIMED_WAITING（进入了同步方法）。
TIMED_WAITING与RUNNABLE状态转换
TIMED_WAITING与WAITING状态类似，只是TIMED_WAITING状态等待的时间是指定的。
Thread.sleep(long)
使当前线程睡眠指定时间。需要注意这里的“睡眠”只是暂时使线程停止执行，并不会释放锁。时间到后，线程会重新进入RUNNABLE状态。
Object.wait(long)
wait(long)方法使线程进入TIMED_WAITING状态。这里的wait(long)方法与无参方法wait()相同的地方是，都可以通过其他线程调用notify()或notifyAll()方法来唤醒。
不同的地方是，有参方法wait(long)就算其他线程不来唤醒它，经过指定时间long之后它会自动唤醒，拥有去争夺锁的资格。
Thread.join(long)
join(long)使当前线程执行指定时间，并且使线程进入TIMED_WAITING状态。
我们再来改一改刚才的示例:
public void blockedTest() { ······ a.start(); a.join(1000L); b.start(); System.out.println(a.getName() + ":" + a.getState()); // 输出 TIEMD_WAITING System.out.println(b.getName() + ":" + b.getState()); }这里调用a.join(1000L)，因为是指定了具体a线程执行的时间的，并且执行时间是小于a线程sleep的时间，所以a线程状态输出TIMED_WAITING。
b线程状态仍然不固定（RUNNABLE或BLOCKED）。
线程中断
在某些情况下，我们在线程启动后发现并不需要它继续执行下去时，需要中断线程。目前在Java里还没有安全直接的方法来停止线程，但是Java提供了线程中断机制来处理需要中断线程的情况。
线程中断机制是一种协作机制。需要注意，通过中断操作并不能直接终止一个线程，而是通知需要被中断的线程自行处理。
简单介绍下Thread类里提供的关于线程中断的几个方法：
- Thread.interrupt()：中断线程。这里的中断线程并不会立即停止线程，而是设置线程的中断状态为true（默认是flase）；
- Thread.currentThread().isInterrupted()：测试当前线程是否被中断。线程的中断状态受这个方法的影响，意思是调用一次使线程中断状态设置为true，连续调用两次会使得这个线程的中断状态重新转为false；
- Thread.isInterrupted()：测试当前线程是否被中断。与上面方法不同的是调用这个方法并不会影响线程的中断状态。
在线程中断机制里，当其他线程通知需要被中断的线程后，线程中断的状态被设置为true，但是具体被要求中断的线程要怎么处理，完全由被中断线程自己而定，可以在合适的实际处理中断请求，也可以完全不处理继续执行下去。
495
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
