线程状态

对于线程来一般有以下几种状态

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 方法
1. 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之前，对线程是无影响的

线程状态与方法

线程状态与方法

线程状态

1. 创建状态（New）

2. 运行状态（Runnable）

3. 阻塞状态（Blocked）

4.等待状态(WAITING)

5.超时等待状态(TIMED_WAITING)

6. 死亡状态（TERMINATED）

线程方法

1.sleep

2.wait

3.notify、notifyAll

4.join

5.yield

6.interrupt

7.isAlive

8.LockSupport.park