系列：

并发 · 一 —— 线程

并发 · 二 —— 互斥锁（synchronized 和 Lock）

并发 · 三 —— 原子性与易变性

线程有四种状态：新建、就绪、阻塞和死亡。

1）新建：当线程被创建时，它只会短暂地处于这种状态，在这段时间内，主要会执行一些初始化的的操作。

2）就绪：在这种状态下，只要调度器把时间片分配给线程，该线程就可以运行了。

3）阻塞：线程能够运行，但是有某个条件阻止它的运行。当线程处于阻塞状态时，调度器将忽略线程，不会分配给线程任何的CPU时间。直到线程重新进入了就绪的状态，调度器才会继续分配CPU时间给它。

4）死亡：处于该状态的线程将不再是可调度的，并且再也不会得到CPU时间，它的任务已结束了。任务死亡的通常方式是从run()方法返回。

注意：线程中的stop()方法已经被弃用了，主要是因为它不释放线程获取的锁，并且如果线程处于不一致的状态，其它任务可以在这种状态下浏览并修改它们，这样锁产生的问题就很难被发现了。

进入阻塞状态几种方式：

1）通过调用sleep(millisecond)使任务进入休眠状态，在这种情况下，任务在指定的时间内处于阻塞状态，不会获得CPU时间，并且不会释放线程自身所持有的锁（区别于调用wait()将线程挂起）。

2）调用wait()使线程挂起，直到线程得到了notify()或notifyAll()消息，线程重新才会进入就绪状态。

3）任务在等待某个输入/输出完成。

4）任务试图在某个对象上调用其同步控制方法，但是对象锁不同，此时就会被阻塞了。

**中断

常规手动停止线程的方法就是通过设置标志位的方法或者到达预先埋好的返回代码的位置，切记，stop()方法已经弃用了，由于不稳定，无法正常释放锁

public class text1 {
	
	volatile static boolean stop = false;
	
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (!stop) {
					System.out.println("运行中。。");
				}
			}
		}).start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		stop = true;
	}
}

1、interrupt()

在Thread类提供interrupt()方法，用于中止正在被阻塞的任务。当打断一个正在被阻塞的任务时，通常还需要清理资源，这正如处理抛出异常，由于有这种需求存在，Java在设计阻塞时中断方法时，即在调用interrupt()设置线程为中断状态后，如果线程遇到阻塞就会抛出InterruptedException异常，并且将会重置线程的中断状态。例如

public class text2 {
	
	public static void main(String[] args) {
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				interrupt();// 将线程设置为中断状态
				
				System.out.println("遇到阻塞");				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					System.out.println("阻塞被打断");
					// 在这里清理资源
					e.printStackTrace();
				}
				
				System.out.println("又遇到阻塞");				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					System.out.println("阻塞被打断");
					// 在这里清理资源
					e.printStackTrace();
				}
				System.out.println("结束线程");
			}
		}.start();
	}
}

>> 运行的结果

遇到阻塞
阻塞被打断
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at text$1.run(text.java:19)
又遇到阻塞
结束线程

>>

从运行结果，我们可以看出，在调用interrupt()方法线程就被设置为中断状态，一旦遇到阻塞，就会立马中断阻塞，并抛出异常，并且重置中断状态位，当下次遇到阻塞就不会被中断并抛出异常。可以这么理解，调用interrupt()，便将线程的中断标志位置为true，当遇到阻塞（或者在调用interrupt方法中，正处于阻塞），都会立马中断阻塞，将线程的中断标志位置为false，并抛出异常。

public class text3 {
	public static void main(String[] args) {
		Thread t = new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				System.out.println("遇到阻塞");				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					System.out.println("阻塞被打断");
					// 在这里清理资源
					e.printStackTrace();
				}
				System.out.println("阻塞结束");
				System.out.println("结束线程");
			}
		};
		t.start();
		try {
			Thread.sleep(500); // 为了确保线程已经运行
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("调用interrupt（）");
		t.interrupt();
	}
}

>> 运行结果

遇到阻塞
调用interrupt（）
阻塞被打断
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at text$1.run(text.java:17)
阻塞结束
结束线程

>>

正如上面的运行结果可以看出，如果线程正处于阻塞状态，调用interrupt()方法，会立马打断阻塞并抛出异常。

2、Thread.interrupted();

 除了遇到阻塞会抛出异常，并重置线程中断状态，Thread还有提供了一个interrupted()的静态方法，可以将当前的线程的中断状态重置。将上面第一个例子text1改进一下，它将不会阻塞被中断

public class text1_1 {
	
	public static void main(String[] args) {
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				interrupt(); // 将线程置为中断状态
				Thread.interrupted(); // 重置线程中断状态
				System.out.println("遇到阻塞");				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					System.out.println("阻塞被打断");
					// 在这里清理资源
					e.printStackTrace();
				}
				System.out.println("阻塞结束");
				System.out.println("结束线程");
			}
		}.start();
		
	}

>> 运行结果

遇到阻塞
阻塞结束
结束线程

>>

3、isInterrupted()

可以通过调用这个方法打印当前线程的中断状态

public class text4 {
	public static void main(String[] args) {
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				interrupt(); // 设置中断状态
				System.out.println(interrupted()); // 打印中断状态
			}
		}.start();
		
	}
}

>>运行结果

true
>>

注意：当I/O和synchronized块上的等待是不可中断的的，也不需要InterruptException处理器。中断可以打断的有调用sleep（）、调用wait（）调起将线程挂起。

正文到这就完了

一、状态简介

一个线程的生命周期里有五大状态，分别是：

1. 新生
2. 就绪
3. 运行
4. 死亡
5. 运行后可能遇到的阻塞状态

二、相关方法

2.1 新生状态

Thread t = new Thread();

正如我们前面所说的，一个线程开始之后有自己的内存空间，这些工作空间和主内存进行交互，从主内存拷贝数据到工作空间。

当这个语句执行的时候，线程创建，开辟工作空间，也就是线程进入了新生状态。

2.2 就绪状态

普通情况，一旦调用了：

t.start();

start 方法被调用，线程立即进入了就绪状态，表示这个线程具有了运行的条件，但是还没有开始运行，这就是就绪状态。

线程就绪，但不意味着立即调度执行，因为要等待CPU的调度，一般来说是进入了就绪队列。

但是还有另外三种情况，线程也会进入就绪状态，四种分别是：

1. start()方法调用；
2. 本来处于阻塞状态，后来阻塞解除；
3. 如果运行的时候调用 yield() 方法，避免一个线程占用资源过多，中断一下，会让线程重新进入就绪状态。注意，如果调用 yield() 方法之后，没有其他等待执行的线程，此线程就会马上恢复执行；
4. JVM 本身将本地线程切换到了其他线程，那么这个线程就进入就绪状态。

2.3 运行状态

当CPU选定了一个就绪状态的线程，进行执行，这时候线程就进入了运行状态，线程真正开始执行线程体的具体代码块，基本是 run() 方法。

注意，一定是从 就绪状态 - > 运行状态，不会从阻塞到运行状态的。

2.4 阻塞状态

阻塞状态指的是代码不继续执行，而在等待，阻塞解除后，重新进入就绪状态。

也就是说，阻塞状态发生肯能是运行状态转过去的， 运行状态 - > 阻塞状态，不会从就绪状态转过去。

阻塞的方法有四种：

1. sleep()方法，是占用资源在睡觉的，可以限制等待多久；
2. wait() 方法，和 sleep() 的不同之处在于，是不占用资源的，限制等待多久；
3. join() 方法，加入、合并或者是插队，这个方法阻塞线程到另一个线程完成以后再继续执行；
4. 有些 IO 阻塞，比如 write() 或者 read() ，因为IO方法是通过操作系统调用的。

上面的方法和start() 一样，不是说调用了就立即阻塞了，而是看CPU。

2.5 死亡状态

死亡状态指的是，线程体的代码执行完毕或者中断执行。一旦进入死亡状态，不能再调用 start() 。

让线程进入死亡状态的方法是 stop() 和 destroy() 但是都不推荐使用，jdk里也写了已过时。

一般的做法是，在线程内，让线程自身自然死亡，或者加一些代码，想办法让线程执行完毕。

1. 自然死亡：这个线程体里就是多少次的循环，几次调用，执行完了就完了。
2. 如果不能自然死亡：加一些终止变量，然后用它作为run的条件，这样，外部调用的时候根据时机，把变量设置为false。

比如下面的写法，第一种就是我们的正常写法（虽然很简单但是没有用lambda表达式，主要为了和第二种对比）

/*
    终止线程的方法1：自然死亡
*/
public class Status implements Runnable{
    @Override
    public void run() {
        for (int i=0; i<20; i++){
            System.out.println("studying");
        }
    }

    public static void main(String[] args) {
        Status s = new Status();
        new Thread(s).start();
    }
}

/*
    终止线程的方法2：外部控制
*/
public class Status implements Runnable{
    //1.加入状态变量
    private boolean flag = true;
    @Override
    //2.关联状态变量
    public void run() {
        while (flag){
            System.out.println("studying");
        }
    }
    //3.对外提供状态变量改变方法
    public void terminate() {
        this.flag = false;
    }
    public static void main(String[] args) {
        Status s = new Status();//1.新生
        new Thread(s).start();//2.就绪，随后进入运行
        //无人为阻塞
        for (int i=0; i<100000; i++){
            if (i==80000){
                s.terminate();//3.终止
                System.out.println("结束");
            }
        }
    }
}

三、阻塞状态详解

上面的内容，线程的五大状态里，其他四种都比较简单，创建对象的新生态、start开始的就绪态、cpu调度之后进入的运行态，以及正常结束或者外加干预导致的死亡态。

3.1 sleep()

• sleep(时间)指定当前线程阻塞的毫秒数：
• sleep存在异常：InterruptException；
• sleep时间到了之后线程进入就绪状态；
• sleep可以模拟网络延时、倒计时等；
• 每一个对象都有一个无形的锁，sleep不会释放锁。（也就是我们说过的，抱着资源睡觉，这个特点对比wait）

前面用线程模拟抢票的网络延时，已经做过示例，就是用sleep设置线程阻塞的时间，达到网络延时的效果，让那个同步问题更容易显现出来。

我们再用龟兔赛跑的例子修改一下，前面兔子和乌龟都是一样各自跑，这次让兔子骄傲的爱睡觉，每隔一段路就睡一段时间。

public class Racer2 implements Runnable{
    private String winner;
    @Override
    public void run() {
        for (int dis=1; dis<=100; dis++){
            String role = Thread.currentThread().getName();
            //模拟兔子睡觉
            if (dis%10==0 && role.equals("兔子")){
                try {
                    Thread.sleep(500);//睡
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(role + " 跑了 " + dis);
            //每走一步，判断是否比赛结束
            if (gameOver(dis))break;
        }
    }

    public boolean gameOver(int dis){
        if (winner != null){
            return true;
        } else if (dis == 100){
            winner = Thread.currentThread().getName();
            System.out.println("获胜者是 "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Racer2 racer = new Racer2();//1.创建实现类
        new Thread(racer,"兔子").start();//2.创建代理类并start
        new Thread(racer,"乌龟").start();
    }
}

这里面：

Thread.sleep(500);//睡

就是让线程进入阻塞状态，并且 500 ms 后，自动进入就绪状态，由 cpu 调度适时重新运行。

也可以利用 sleep 模拟倒计时，不涉及多个线程，所以直接在主线程里面，主方法里写内容就可以，也不用run什么，直接调用sleep设置阻塞时间。

public class SleepTime {
    public static void main(String[] args) throws InterruptedException {
        int num = 10;
        while (num>=0){
            Thread.sleep(1000);
            System.out.println(num--);
        }
    }
}

这就会完成10-0 的倒计时。

更花哨一点，用 Dateformat 和 Date 实现时间的显示：

public static void main(String[] args) throws InterruptedException {
    //获取十秒后的时间，然后倒计时
    Date endTime = new Date(System.currentTimeMillis()+1000*10);
    //干预线程的结束
    long end = endTime.getTime();
    DateFormat format = new SimpleDateFormat("mm:ss");
    while (true) {
        System.out.println(format.format(endTime));
        Thread.sleep(1000);
        endTime = new Date(endTime.getTime() - 1000);//-1s
        if (end-10000 > endTime.getTime()){
            break;
        }
    }
}

3.2 wait() && notify()

和 sleep() 不同，wait() 方法和 notify() 搭配，可以互相搭配，一个经典的的使用场景以及介绍是在生产者-消费者模型中：

生产者消费者模型详解

3.3 yield()

礼让线程，让当前正在执行的线程暂停，不阻塞线程，而是直接将线程从运行状态转入就绪状态，让cpu调度器重新调度。

用法和 sleep 是一样的，也是一个静态方法，调用起来的效果比 sleep 弱。

这是因为，礼让之余，还有 cpu 的调度在影响顺序，所以无法保证达到线程切换的效果， cpu 还是可能调用当前的线程。

3.4 join()

join 合并线程，待此线程执行完成后，再执行其他线程。也就是说，阻塞其他的所有线程，所以其实应该是插队线程，所以 join 应该翻译成加入，插入？。

不同于 sleep 和 yield 方法，join 不是静态方法，是一个普通方法，要通过一个具体的 Thread 对象才能调用 join。

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i=0; i<100; i++){
                System.out.println("myThread is joining" + i);
            }
        });

        t.start();

        for (int i=0; i<100; i++){
            if (i == 50){
                t.join();//插队，此时主线程不能执行，而要执行 t
            }
            System.out.println("main is running" + i);
        }
    }
}

执行结果可以看出来，等到主线程执行到 i = 50后，t 线程完全执行，直到结束，才继续执行 main 线程。

（当然，在 i = 50 之前，是不确定的，cpu 给两个线程的安排）

join 的最重要的部分，就是插队可以保证，这个线程自己一定会先执行完，这是在很多地方需要的逻辑。

四、利用枚举变量监控线程状态

回过头看线程的状态转换图：

新生态、死亡态、除了阻塞内部，其他都已经进行了练习，其中，就绪态到运行态之间是不由程序员控制的，所以 java 给这两个状态了一个统一的名称叫 Runnable（不要和Runnable接口搞混）。

java jdk 里面对于线程状态的区分：

1. NEW 对应没有 Started 的线程，对应新生态；
2. RUNNABLE，对于就绪态和运行态的合称；
3. BLOCKED,WAITING,TIMED_WAITING三个都是阻塞态：
   • sleep 和 join 称为WAITING,TIMED_WAITING（设置了时间的话）；
   • wait 和 IO 流阻塞称为BLOCKED。
4. TERMINATED 死亡态。

我们用一个 demo 观察一下状态的切换过程：

public class AllState {
    public static void main(String[] args) throws InterruptedException {
        //一个拥有阻塞的线程
        Thread t = new Thread(()->{
            for (int i=0; i<10; i++){
                try {
                    Thread.sleep(200);//阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("........I am running.........");
            }
        });

        System.out.println(t.getState());//获取状态，此时应该是new

        t.start();
        System.out.println(t.getState());//获取状态，此时已经start

        //监控阻塞，设置结束条件为监控到 t 线程已经变成 Terminated
        while (!t.getState().equals(Thread.State.TERMINATED)){
            Thread.sleep(200);//主线程每200ms监控一次线程 t
            System.out.println(t.getState());
        }
    }
}

从输出结果可以看到，从 开始的 new 到 runnable（start后），到有线程执行了 running 的runnable，到阻塞的 timed_waiting ，到恢复 runnable，到最终的结束 terminated。

Thread 还提供了线程数方法，可以计数，结束条件其实还可以改成对于线程数的判断，因为当 t 结束后，线程数就只剩下主线程了。

while (Thread.activeCount() != 1){
    System.out.println(Thread.activeCount());
    Thread.sleep(200);//主线程每200ms监控一次线程 t
    System.out.println(t.getState());
}

然而，运行起来的时候输出显示的是 3 个线程：

最后 terminated 之后陷入了线程数是 2 的死循环，和预想的不一样。。。

引入了另一个问题，搜了一下，应该是控制台输出，也是一个线程被监控的。

• sleep( ) 使线程在一定的时间内进入阻塞状态，不能得到cpu时间，但不会释放锁资源。指定的时间一过，线程重新进入可执行状态

• wait( ) 使线程进入阻塞状态，同时释放自己占有的锁资源，和notify( )搭配使用

• suspend( ) 使线程进入阻塞状态，并且不会自动恢复，必须其对应的resume( )被调用，才能使线程重新进入可执行状态

区别：

yield( ) 使得线程放弃当前分得的CPU时间，但是不使线程阻塞，即线程任然处于可执行状态，随时可能再次分得CPU时间。

其中sleep(),suspend(),rusume(),yield()均为Thread类的方法，wait()为Object类的方法