线程状态与方法
线程状态
对于线程来一般有以下几种状态
1. 创建状态（New）
每次我们新建线程例如,这种线程就处于创建状态
Thread thread1 = new Thread(synchronizedTest3);
2. 运行状态（Runnable）
我们调用线程start()方法就使线程处于就绪状态，很多地方将线程状态分为就绪状态和运行中状态，对于我们理解来说，就绪状态相当于获取CPU的排队权限，运行中状态相当于获取了CPU占用权限，获取了CPU运行的排队权限，并不一定在占用CPU。（可以理解为相当于排队付款一样，就绪状态只是排在队列中，但不一定正在付款）
这里为什么把这2种归为一类而说，是因为一、JDK Thread类中只有Runnable状态，二、对于线程从获取CPU的排队权限，到真正占用CPU，这个是由系统决定的，我们没法改变（线程从占用CPU到获取CPU排队权限可以通过yield方法谦让当前线程占用）。
我们理解线程的几种状态一定要基于CPU去理解，因为线程的状态最终反应在是否获取CPU运行排队权限，是否正在CPU占用。我们对于线程一些sleep(),wait()之类的操作只是放弃了当前程序CPU运行权限。
对于线程来说只能从就绪状态由系统调用进入运行中状态。后续我们统一称CPU运行的排队权限和CPU占用权限为运行权限。
3. 阻塞状态（Blocked）
处于此状态会放弃对CPU运行权限。进入此状态由2种方式进入
- 1.线程等待进入synchronized 方法或块
- 2.线程唤醒之后等待进入synchronized 方法或块（notify通知wait）
4.等待状态(WAITING)
处于这种状态的线程暂时放弃对CPU的运行权限。由以下三种情况进入等待状态：
- 1.Object的wait方法
- 2.Thread.join 方法
- LockSupport.park方法
5.超时等待状态(TIMED_WAITING)
有限时间内的等待状态
6. 死亡状态（TERMINATED）
线程代码执行结束，停止对CPU占用
线程方法
下面我们看下线程一些常用方法对于线程状态的影响
先放一张图片，来源《JAVA并发编程的艺术》
image.png
1.sleep
线程休眠，会让出cpu资源，但不是释放对象内置锁，sleep会导致其他线程也访问不到当前代码
public class SleepDemo {
public static void main(String []args) throws InterruptedException {
SleepDemo sleepDemo = new SleepDemo();
Thread thread1 = new Thread("t1"){
@Override
public void run(){
synchronized (sleepDemo){
try {
System.out.println("t1进入休眠"+System.currentTimeMillis());
Thread.sleep(10000);
System.out.println("t1休眠结束"+System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread2 = new Thread("t2"){
@Override
public void run(){
synchronized (sleepDemo){
System.out.println("t2进来了"+System.currentTimeMillis());
}
}
};
thread1.start();
Thread.sleep(1000);
thread2.start();
}
}
结果如下
t1进入休眠1564908687577
t1休眠结束1564908697578
t2进来了1564908697578
2.wait
wait方法其实是位于Object类下（JAVA提供的锁是对象级），wait方法执行前需要获取当前对象锁，wait方法相当于同时释放掉对象内置锁和当前CPU运行权限，所以wait方法运行前必须获取到对象内置锁（Monitor）synchronized。
这里写个简单的小例子
public class WaitDemo {
public static void main(String []args) throws InterruptedException {
WaitDemo waitDemo = new WaitDemo();
Thread thread1 = new Thread("t1"){
@Override
public void run(){
synchronized (waitDemo){
try {
System.out.println("t1进入等待");
waitDemo.wait();
//我们没有写对象的唤醒，所以这句话不会输出出来
System.out.println("t1等待结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread2 = new Thread("t2"){
@Override
public void run(){
synchronized (waitDemo){
//因为wait会释放掉waitDemo的内置锁，所以可以显示这句话会第二输出
System.out.println("t2进来了");
}
}
};
thread1.start();
Thread.sleep(1000);
thread2.start();
}
}
结果如下
t1进入等待
t2进来了
3.notify、notifyAll
notify和notifyAll方法也位于Object类下，notify和notifyAll方法执行前需要获取当前对象内置锁（Monitor）synchronized。同样也会释放当前对象锁,但是notify释放锁是在包含它的synchronized方法执行完之后才释放掉synchronized锁。例子如下
public class NotifyDemo {
public static void main(String []args) throws InterruptedException {
NotifyDemo notifyDemo = new NotifyDemo();
Thread thread1 = new Thread("t1"){
@Override
public void run(){
synchronized (notifyDemo){
try {
System.out.println("t1进入等待"+System.currentTimeMillis());
notifyDemo.wait();
System.out.println("t1等待结束"+System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread2 = new Thread("t2"){
@Override
public void run(){
synchronized (notifyDemo){
System.out.println("t2进来了"+System.currentTimeMillis());
notifyDemo.notify();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2执行完毕了"+System.currentTimeMillis());
}
}
};
thread1.start();
Thread.sleep(1000);
thread2.start();
}
}
结果如下
t1进入等待1564909412115
t2进来了1564909413116
t2执行完毕了1564909423117
t1等待结束1564909423117
4.join
join方法如下
/**如果这个线程存活，则一直等待，直到这个线程结束，然后调用notifyAll通知其他在当前线程实例上所有线程（调用notifyAll方法过程是在虚拟机中调用c++代码实现）
注意一点：不要在线程实例上调用wait、notify、notifyAll方法
**/
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
/****/
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
其实相当于告诉其他线程，等待当前线程执行完毕再往下执行,如果我们要保证2个线程顺序执行，应该采用下面这种方式，这种情况下，join会让主线程一直等待，直到thread1消亡通知主线程
thread1.start();
thread1.join();
thread2.start();
thread2.join();
5.yield
会释放掉当前线程占用的CPU资源，但是当前线程也会参与到线程占用cpu的竞争中去，简单来说，就类似10个人抢箱子，甲先抢到了箱子，然后他又把箱子放回去了，大家再开始抢
6.interrupt
也是我们平常说的中断，我们常见的方法有
//将当前线程中断标记 标记为true
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}
//查看线程是否处于中断，true代表处于中断,但是不会重置中断状态
public boolean isInterrupted() {
return isInterrupted(false);
}
//清除线程中断标记,会重置中断状态
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
//查看线程是否处于中断，ClearInterrupted为True，如果当前线程处于中断状态则重置中断状态
private native boolean isInterrupted(boolean ClearInterrupted);
调用interrupt()方法仅仅是在当前线程中打了一个停止的标记，只是将线程的中断标记置为true，并不是真的停止线程。意味着如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，会不断查询线程的中断标记，如果为true，则停止阻塞并抛出InterruptedException异常。如果为false，则继续阻塞。
注意一点，在调用Object.wait, Thread.join和Thread.sleep方法之后，会清除掉中断标记，如果我们还需要中断标记，需要再次对线程进行interrupt()方法。
这里看个简单使用例子
public class InterruptDemo extends Thread {
@Override
public void run() {
Thread.currentThread().interrupt();
System.out.println("子线程执行中断请求结果1："+Thread.currentThread().isInterrupted());
System.out.println("子线程执行中断请求结果2："+Thread.currentThread().isInterrupted());
}
public static void main(String []args) throws InterruptedException {
InterruptDemo interruptDemo = new InterruptDemo();
interruptDemo.start();
Thread.sleep(1000);
Thread.currentThread().interrupt();
System.out.println("主线程执行中断请求结果1："+Thread.currentThread().isInterrupted());
System.out.println("主线程执行中断请求结果2："+Thread.currentThread().isInterrupted());
System.out.println("主线程执行中断请求结果3："+Thread.interrupted());
//因为Thread会重置主线程终端状态所以第二次请求为false
System.out.println("主线程执行中断请求结果4："+Thread.interrupted());
}
}
结果如下,这种情况可以看到主线程第二次请求interrupted()为false
子线程执行中断请求结果1：true
子线程执行中断请求结果2：true
主线程执行中断请求结果1：true
主线程执行中断请求结果2：true
主线程执行中断请求结果3：true
主线程执行中断请求结果4：false
再看下我们刚才说的注意点
public class InterruptDemo2 extends Thread {
@Override
public void run() {
while(!Thread.currentThread().isInterrupted()){
try {
System.out.println("线程执行休眠开始");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//可以尝试注掉这句话
Thread.currentThread().interrupt();
}
}
}
public static void main(String []args) throws InterruptedException {
InterruptDemo2 interruptDemo = new InterruptDemo2();
interruptDemo.start();
Thread.sleep(1000);
System.out.println("主线程睡眠结束");
interruptDemo.interrupt();
System.out.println("执行中断请求");
}
}
运行结果如下
线程执行休眠开始
主线程睡眠结束
java.lang.InterruptedException: sleep interrupted
执行中断请求
at java.lang.Thread.sleep(Native Method)
at com.example.consumerdemoone.thread2.InterruptDemo2.run(InterruptDemo2.java:15)
如果我们注释掉finally的中断操作，线程会一直执行下去，结果如下
线程执行休眠开始
java.lang.InterruptedException: sleep interrupted
主线程睡眠结束
at java.lang.Thread.sleep(Native Method)
执行中断请求
线程执行休眠开始
at com.example.consumerdemoone.thread2.InterruptDemo2.run(InterruptDemo2.java:15)
线程执行休眠开始
线程执行休眠开始
线程执行休眠开始
线程执行休眠开始
线程执行休眠开始
7.isAlive
判断当前线程是否处于运行中。返回true是处于运行中线程
8.LockSupport.park
LockSupport.park();
阻塞线程
LockSupport.unpark(t1);
解除阻塞线程，如果unpark发生在park之前，对线程是无影响的
