Java 线程的六种状态以及切换
摘录于：
Java 中线程的六种状态：
- 初始（NEW）：新创建一个线程对象，但是还没有调用 start 方法
- 运行（RUNNABLE）：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
- 阻塞（BLOCKED）：表示线程阻塞于锁
- 等待（WAITING）：进入该状态的线程需要等待其他线程做出一些特定的动作（通知或者终端）
- 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
- 终止（TERMINATED）：表示该线程已经执行完毕
线程状态图
状态详细说明
初始状态（NEW）
实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。
就绪状态（RUNNABLE 之 READY）
- 就绪状态只是说你资格运行，调度程序(CPU)没有挑选到你，你就永远是就绪状态。
- 调用线程的start()方法，此线程进入就绪状态。
- 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
- 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
- 锁池里的线程拿到对象锁后，进入就绪状态。
运行中状态（RUNNABLE 之 RUNNING）
线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式
阻塞状态（BLOCKED）
阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
等待（WAITING）
处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
超时等待（TIMED-WAITING）
处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
终止状态（TERMINATED）
- 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
- 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
等待队列、锁池
-
调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
-
与等待队列相关的步骤和图：
线程几种方法的比较
-
Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，会释放cpu资源，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
-
Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。 作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
-
thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
-
Object.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，会释放cpu资源，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
-
Object.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
-
LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。
-
Thread.interrupt()，当前线程调用此方法，本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识位。这个线程本身不会因此改变状态（如阻塞，终止等）
-
调用 interrupt() 方法不会中断一个正在运行的线程，仅仅改变了内部维护的中断标识位。
-
若调用sleep()方法而使线程处于TIMED-WAITING状态，这时调用interrupt()方法，会抛出InterruptedException，从而使线程提前结束TIMED-WAITING状态。
-
声明抛出InterruptedException的方法，会清除中断标识位。
-
中断状态使线程固有的一个标识位，可以通此标识位安全终止线程。比如调用线程thread时，调用thread.interrupt()，在线程run方法中可以调用thread.isInterrupted()的值来优雅的终止线程。
https://www.liaoxuefeng.com/wiki/1252599548343744/1306580767211554
-
创建线程的方式
Thread
线程运行的过程会产生很多信息，这些信息都保存在Thread类中的成员变量里面，常见的有：
- 线程的ID是唯一标识getId()
- 线程的名称：getName()，如果不设置线程名称默认为“Thread-xx”
- 线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时获得JVM调度执行的可能性越大。一般不推荐设置线程的优先级，如果进行设置了非法的优先级程序就会出现IllegalArgumentException异常。
继承 Thread 类，重写 run 方法
步骤：
- 定义一个类继承Thread类
- 重写Thread类的run方法
- 直接创建Thread的子类对象创建线程
- 调用start方法开启线程并调用线程的run方法执行
class Demo extends Thread {
private String name;
Demo (String name) {
super(name); // 修改线程名称
}
@Override
public void run () {
System.out.println(Thread.currentThread().getName());
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d1 = new Demo("emiya");
Demo d2 = new Demo("cirou");
d1.start();
d2.start();
}
}
实现 Runnable 接口，重写 run 方法
步骤：
-
定义类实现Runnable结构
-
重写接口中的run方法，将线程的任务代码封装到run方法中
-
通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递
为什么：因为线程的任务都封装在Runnable接口子类对象的run方法中，所以在线程对象创建时就必须明确要运行的任务
思想：将线程的任务通过Runnable接口封装成对象
-
调用线程对象的start方法开启线程
好处：
- 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
- 避免了java单继承的局限性。
class Demo implements Runnable {
@Override
public void run() {
show();
}
public void show() {
System.out.println(Thread.currentThread().getName());
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
实现 Callable 接口，重写 run 方法
对比使用Runnable，Callable功能更强大
- 相比run方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutrueTask是Futrue接口的唯一的实现类
- FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值
//1.创建一个实现Callable的实现类
class Stu implements Callable {
//2.重写call方法,将此线程需要执行的操作生命call()中
@Override
public Object call() throws Exception {
int res = 0;
System.out.println(res);
return res;
}
}
public class Bank {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
Stu stu = new Stu();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(stu);
//5.FutureTask的对象作为参数传递到Thread类的构造器中创建Thread，并调用start()
new Thread(futureTask).start();
try {
Object res = futureTask.get();
System.out.println(res);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
使用线程池
背景：经常创建、销毁和使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池。可以避免频繁的创建销毁，实现重复利用。
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池的线程，不需要每次都创建）
- 便于线程管理
// 线程池参数
corePoolSize: 核心线程数;
maximumPoolsize: 最大线程数;
keepAliveTime: 线程没有任务最多保持多长时间会停止;
unit: keepAliveTime的单位;
workQueue: 任务队列，被提交但未执行的任务;
threadFactory: 线程工厂，用于创建线程，一般用默认;
handler: 拒绝策略，任务太多来不及处理时，如何拒绝任务;
class MyThread implements Runnable {
@Override
public void run () {
System.out.println("mythread");
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.提供指定线程的数量
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程的属性
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程并执行相关的run()
service.execute(new MyThread()); // 适用于Callable
service.submit(); // 适用于Callable
// 3.结束线程的使用
service.shutdown();
}
}