一、前言
本文介绍Java线程相关知识（不包括线程同步+线程通信，这个内容在笔者的另一篇博客中介绍过了），包括：线程生命周期、线程优先级、线程礼让、后台线程、联合线程。
二、线程生命周期
2.1 引子：线程生命周期
本节阐述线程生命周期相关知识，Java支持多线程技术，除了Main函数主导一个main线程以外，可以用代码创建一系列的前台线程、后台线程（本文后面会讲），每一个线程都有自己的生命周期，线程生命周期的不同状态有不同的说法：
（1）有的说Java线程5种状态，这是因为将“等待状态Waiting+限时等待状态Timed_Waiting”作为一种状态，5种状态为：
新建状态New、可运行状态Runnable(Running+Ready)、等待状态Waiting+Timed_Waiting、阻塞状态Blocked、结束状态Terminated
（2）有的说Java线程6种状态，这是因为将将Running和Ready两种状态拆分开了，6种状态为：
新建状态New、准备状态Ready、运行状态Running、等待状态Waiting+Timed_Waiting、阻塞状态Blocked、结束状态Terminated
或者将等待状态Waiting和限时等待状态Timed_Waiting两种状态拆开，6种状态为：
新建状态New、可运行状态Runnable(Running+Ready)、等待状态Waiting、计时等待状态Timed_Waiting、阻塞状态Blocked、结束状态Terminated
（3）有的说Java线程7种状态，这是因为将将Running和Ready两种状态拆分开、等待状态Waiting和限时等待状态Timed_Waiting两种状态拆开，7种状态为：
新建状态New、准备状态Ready、运行状态Running、 等待状态Waiting、计时等待状态Timed_Waiting、阻塞状态Blocked、结束状态Terminated
不管采用哪种说法，Java线程状态以下几种，新建状态New、可运行状态Runnable(Running+Ready)、等待状态(等待状态Waiting+限时等待状态Timed_Waiting)、阻塞状态Blocked、结束状态Terminated
本文采用6种状态的说法，下面2.3 会具体阐述。
2.2 用一段代码来演示一个完整的生命周期
代码1：
package mypackage;
// 线程的生命周期，演示线程的六种状态： NEW 新建状态 RUNNABLE 可运行状态（ready就绪状态+running运行状态） TIMED_WAITING 计时等待状态
// WAITING 等待状态 BLOCKED 阻塞状态 TERMINATED 终止状态（进入终止状态后只能结束，无法再返回回来）
class Block { //共享资源类
public boolean waitStatus = true;
public void waitOp() throws InterruptedException {
synchronized (this) {
System.out.println(Thread.currentThread().getName() + " 进入wait");
wait();
// waitThread被notifyThread唤醒
System.out.println(Thread.currentThread().getName() + " next to Block.wait(), in the loop");
}
}
public void notifyOp() {
synchronized (this) {
this.waitStatus = false; // 修改标志位 等待状态waitStatus=false
notifyAll(); // 唤醒WaitRunnable
System.out.println(Thread.currentThread().getName() + " 向正在wait当前对象的线程发出notify");
}
}
}
class WaitThread implements Runnable {
private Block block;
public WaitThread(Block block) {
super();
this.block = block;
}
@Override
public void run() {
//该方法中测试了 sleep(毫秒数)进入计时等待状态和wait()进入等待状态
// 前者只能等待2秒后自动唤醒 后者由notifyThread使用notify()/notifyAll()唤醒
try {
System.out.println(Thread.currentThread().getName() + " 被启动，开始执行...");
// Thread.sleep(毫秒数) 进入计时等待状态 线程计时等待状态中，线程依然存活，线程isAlive() 仍然为true
System.out.println(Thread.currentThread().getName() + " 开始sleep 2s");
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + " 从sleep中醒来");
// 从sleep中醒来后，进入wait状态
while (block.waitStatus) {
block.waitOp(); // 进入等待状态，线程在等待状态中，线程依然存活，线程isAlive()
// 仍然为true，等待状态只有一个出口，notify()/notifyAll()
// waitThread被notifyThread唤醒
System.out.println(Thread.currentThread().getName() + " next to WaitRunnable.waitOp(), in the loop");
}
System.out.println(Thread.currentThread().getName() + " out of wait loop");
System.out.println(Thread.currentThread().getName() + " 任务执行结束，即将终止...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class NotifyThread implements Runnable {
private Block block;
public NotifyThread(Block block) {
super();
this.block = block;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 被启动，开始执行...");
block.notifyOp();
synchronized (block) {
try {
System.out.println(Thread.currentThread().getName() + " 开始sleep 6s，并且不会释放当前对象的锁");
// 进入计时等待状态有两种方式 wait(毫秒数) sleep(毫秒数) 两者不同在于
// wait(毫秒数)释放锁 ,其他线程(本程序中另一个线程)获得锁并运行
// sleep(毫秒数)不释放锁,其他线程(本程序中另一个线程)不可以获得锁并运行
// 现在notifyThread sleep(6000) 不释放锁，所以waitThread也不能运行
// ,只能等到6秒后notifyThread醒来
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// notifyThread醒来了，打印一下
System.out.println(Thread.currentThread().getName() + " 从sleep中醒来");
}
}
public class Test {
private static final String IN_THE_STATE = "当前的状态为：";
private static final String ISALIVE_RETRUN = "isAlive()返回为：";
public static void printStatus(Thread thread) {
System.out.println(thread.getName() + " " + IN_THE_STATE + thread.getState().toString() + " " + ISALIVE_RETRUN
+ thread.isAlive());
}
public static void main(String[] args) throws InterruptedException {
// 该对象将作为后面加锁的对象
Block block = new Block();
// new Thread() 进入新建状态
Thread waitThread = new Thread(new WaitThread(block));
Thread notifyThread = new Thread(new NotifyThread(block));
printStatus(waitThread); // 打印当前状态，当前状态为新建状态 线程尚未启动，isAlive()为false
printStatus(notifyThread);// 打印当前状态，当前状态为新建状态 线程尚未启动，isAlive()为false
// .start() 进入可运行状态 （包括就绪状态和运行状态）
// 就绪状态进入运行状态是CPU调度，程序员无法控制，所本程序中对这两种状态不做区分，统一为可运行状态
waitThread.start();
printStatus(waitThread); // 打印当前状态，当前状态为可运行状态 线程启动，isAlive()为true
Thread.sleep(1000);
// TIMED_WAITING
printStatus(waitThread); // 打印当前状态，当前状态为计时等待状态
Thread.sleep(2000);
// WAITING
printStatus(waitThread); // 打印当前状态，当前状态为wait()等待状态,等待被notifyThread()唤醒才能继续下去
Thread.sleep(1000); // 主线程main线程等待1s
notifyThread.start(); // 启动notify线程，去唤醒处于等待状态的waitThread
printStatus(notifyThread); // 打印notifyThread当前状态，当前状态为可运行状态
// 线程启动，isAlive()为true
Thread.sleep(1000); // 主线程main线程等待1s
// BLOCKED or TERMINATED
// TERMINATED：运行到此处时，如果notifyThread执行完notify操作后，调度器立马切换至thread的情况下，thread会先行终止，调度器再调度notifyThread
printStatus(waitThread); // 现在处于notifyThread sleep(6000) 睡眠6秒过程中 我们打印一下被notifyThread唤醒的waitThread处于什么状态
// waitThread为Block状态,islive为true
//这是因为waitThread虽然被notifyThread唤醒，从等待状态中出来，但是因为notifyThread现在一直占用同步锁，waitThread无法获得同步锁，所以处于阻塞状态
//等待状态和阻塞状态区别：Java中，每个对象都有两个池，锁池和等待池，
//阻塞状态两种：I/O阻塞（本程序不涉及，略）和获取同步锁失败而阻塞（本程序当前情况），线程对象处于锁池，锁池的中线程对象获取到同步锁之后就可以进入可运行状态运行，即阻塞状态的线程获取同步锁成功后就可以运行
//等待和计时等待状态：sleep(毫秒数)只能等待自动唤醒，wait(毫秒数)可以等待自动唤醒或notify()/notifyAll()唤醒，wait()只能notify()/notifyAll()唤醒，三种等待都是处于等待池中
//wait()和wait(毫秒数)释放同步锁，其间不占用同步锁，sleep(毫秒数)占用同步锁，其间不释放同步锁
printStatus(notifyThread); // 现在处于notifyThread sleep(6000) 睡眠6秒过程中
// notifyThread 为计时等待状态,islive为true
Thread.sleep(6000); // 主线程睡眠6s 让两个子程序有足够的时间进入终止状态
// 终止状态 主线程给了6s 足够进入终止状态了
printStatus(waitThread); // waitThread 进入终止状态，isAlive()为false
printStatus(notifyThread); // notifyThread 进入终止状态，isAlive()为false
// 注意：线程一旦进入终止状态，只能结束，无法再返回来
}
}
输出1：
Thread-0 当前的状态为：NEW isAlive()返回为：false
Thread-1 当前的状态为：NEW isAlive()返回为：false
Thread-0 当前的状态为：RUNNABLE isAlive()返回为：true
Thread-0 被启动，开始执行...
Thread-0 开始sleep 2s
Thread-0 当前的状态为：TIMED_WAITING isAlive()返回为：true
Thread-0 从sleep中醒来
Thread-0 进入wait
Thread-0 当前的状态为：WAITING isAlive()返回为：true
Thread-1 当前的状态为：RUNNABLE isAlive()返回为：true
Thread-1 被启动，开始执行...
Thread-1 向正在wait当前对象的线程发出notify
Thread-1 开始sleep 6s，并且不会释放当前对象的锁
Thread-0 当前的状态为：BLOCKED isAlive()返回为：true
Thread-1 当前的状态为：TIMED_WAITING isAlive()返回为：true
Thread-1 从sleep中醒来
Thread-0 next to Block.wait(), in the loop
Thread-0 next to WaitRunnable.waitOp(), in the loop
Thread-0 out of wait loop
Thread-0 任务执行结束，即将终止...
Thread-0 当前的状态为：TERMINATED isAlive()返回为：false
Thread-1 当前的状态为：TERMINATED isAlive()返回为：false
小结：本程序（已经注释的比较清楚了，这里不再赘余）使用synchronized+标志位waitStatus+wait()+notify()/notifyAll()，程序中的两个线程waitThread和notifyThread，既使用到了线程同步+线程通信，又监听了六个状态，帮助读者很好的理解Java线程生命周期六个状态。
2.3 线程生命周期的相关问题
问题（1）：线程有几种状态？状态之间如何转换？
回答（1）：没有绝对的答案，本文采用Java官方的解释，6种状态，分别是 ：NEW 新建状态 RUNNABLE 可运行状态（包括ready就绪状态+running运行状态） TIMED_WAITING 计时等待状态
WAITING 等待状态 BLOCKED 阻塞状态 TERMINATED 终止状态（进入终止状态后只能结束，无法再返回回来）
关于状态之间的转换图，我认为这张图最能符合标准：
补充：因为可运行状态Runnable包括Ready就绪状态和Running运行状态，但是就绪状态进入运行状态是CPU调度，程序员无法控制，所本文中对这两种状态不做区分，统一为可运行状态，两者中转换如图：
问题（2）：六种状态isAlive()返回值？
回答（2）：新建状态和终止状态isAlive()为false,表示线程此时不存活；其他四种状态isAlive()为true，表示线程此时为存活。
问题（3）：进入终止状态terminate还可以再回到可运行状态吗？
回答（3）：不可以，进入终止状态线程只能死亡，不可以再回到可运行状态。
问题（4）：等待状态（包括计时等待）和阻塞状态的区别？wait()、wait(毫秒数)和sleep(毫秒数)区别？
回答（4）：等待状态和阻塞状态区别：Java中，每个对象都有两个池，锁池和等待池，
阻塞状态两种：
I/O阻塞（本程序不涉及，略）和获取同步锁失败而阻塞（本程序当前情况），线程对象处于锁池，锁池的中线程对象获取到同步锁之后就可以进入可运行状态运行，即阻塞状态的线程获取同步锁成功后就可以运行；
等待和计时等待状态：
进入等待状态（包括计时等待）方式有三种（sleep(毫秒数)、wait()、wait(毫秒数)）
sleep(毫秒数)只能等待自动唤醒，wait(毫秒数)可以等待自动唤醒或notify()/notifyAll()唤醒，wait()只能notify()/notifyAll()唤醒，三种等待都是处于等待池中。
另外，wait()和wait(毫秒数)释放同步锁，其间不占用同步锁，sleep(毫秒数)占用同步锁，其间不释放同步锁
| 方法名 | 线程状态 | 唤醒 | 状态期间 |
|---|---|---|---|
| wait() | 进入等待状态 | 只能notify()/notifyAll()唤醒 | 释放同步锁，其间不占用同步锁 |
| wait(毫秒数) | 进入计时等待状态 | 可以等待自动唤醒或notify()/notifyAll()唤醒 | 释放同步锁，其间不占用同步锁 |
| sleep(毫秒数) | 进入计时等待状态 | 只能等待自动唤醒 | 占用同步锁，其间不释放同步锁 |
三、线程优先级
Java中提供了操作线程优先级的方法setter-getter， int getPriority() :返回线程的优先级。 void setPriority(int newPriority) : 更改线程的优先级。 另外，提供了三个表现线程优先级的常量，
MAX_PRIORITY=10,最高优先级
MIN_PRIORITY=1,最低优先级
NORM_PRIORITY=5,默认优先级，
线程优先级有1~ 10,10种，程序员也可以直接使用数字1~10设置线程优先级。线程优先级代码实现且见代码1：
代码——线程优先级：
package mypackage;
public class SimplePriorities implements Runnable {
private int countDown = 5;
public SimplePriorities(int priority) {
Thread.currentThread().setPriority(priority);
}
public String toString() {
return Thread.currentThread() + ": " + countDown;
}
@Override
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}
}
}
public static void main(String[] args) {
new Thread(new SimplePriorities(Thread.MIN_PRIORITY)).start();
new Thread(new SimplePriorities(Thread.MAX_PRIORITY)).start();
}
}
输出：
Thread[Thread-1,10,main]: 5
Thread[Thread-1,10,main]: 4
Thread[Thread-1,10,main]: 3
Thread[Thread-0,1,main]: 5
Thread[Thread-1,10,main]: 2
Thread[Thread-0,1,main]: 4
Thread[Thread-1,10,main]: 1
Thread[Thread-0,1,main]: 3
Thread[Thread-0,1,main]: 2
Thread[Thread-0,1,main]: 1
小结：我们看到，程序开始的时候，即使在客户端低优先级的线程Thread-0先创建和执行，但是输出结果中，高优先级的线程Thread-1可以获得更多执行机会（前面5个，Thread-1打印了4个，Thread-0打印1个，后面5个没有意义，因为Thread-1已经快打印完了，每个线程countDown总数只有5）（注意：打印结果不同且当前线程数和countDown数字较小，特例没有意义）
注意1：值得注意的是，线程优先级并不是指线程执行的先后顺序，而是线程被执行的概率权重。事实上，除非程序员使用标志位做线程通信，否则Java并没有提供任何线程执行先后顺序的机制，哪个线程先执行只取决于CPU调度。
注意2：此外，不同的操作系统支持的线程优先级不同的,建议使用上述三个优先级MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY,不要自定义。
四、线程礼让
线程礼让是以线程优先级为基础的（本文先介绍线程优先级，再介绍线程礼让），线程礼让yield方法只会给相同优先级或者更高优先级的线程运行的机会. 且看如下代码：
代码——线程礼让（在线程优先级代码的基础上添加）：
package mypackage_线程礼让;
public class SimplePriorities implements Runnable {
private int countDown = 5;
public SimplePriorities(int priority) {
Thread.currentThread().setPriority(priority);
}
public String toString() {
return Thread.currentThread() + ": " + countDown;
}
@Override
public void run() {
while (true) {
Thread.yield();
System.out.println(this);
if (--countDown == 0) {
return;
}
}
}
public static void main(String[] args) {
new Thread(new SimplePriorities(Thread.MIN_PRIORITY)).start();
new Thread(new SimplePriorities(Thread.MAX_PRIORITY)).start();
}
}
输出：
Thread[Thread-1,10,main]: 5
Thread[Thread-0,1,main]: 5
Thread[Thread-1,10,main]: 4
Thread[Thread-0,1,main]: 4
Thread[Thread-1,10,main]: 3
Thread[Thread-1,10,main]: 2
Thread[Thread-1,10,main]: 1
Thread[Thread-0,1,main]: 3
Thread[Thread-0,1,main]: 2
Thread[Thread-0,1,main]: 1
小结：在run()方法中加上Thread.yield()之后，可以更大程度上保证高优先级的线程打败低优先级的线程，因为yield()只能将线程礼让给同等优先级和更高优先级的线程，本程序中Thread-0会礼让给Thread-1,但是Thread-1不会礼让给Thread-0,所以Thread.yield()本身更大程度上保证高优先级的线程打败低优先级的线程（注意：不绝对，况且的这里的countDown计数器和客户端线程数都很少）。
附：线程礼让yield()和线程休眠sleep()的相同点和不同点
sleep方法和yield方法的区别:
1):相同点：都能使当前处于运行状态的线程放弃CPU,把运行的机会给其他线程.
2):不同点——转让运行机会的条件不同：sleep方法会给其他线程运行机会,但是不考虑其他线程的优先级,yield方法只会给相同优先级或者更高优先级的线程运行的机会.
3):不同点——转让后进入的状态不同：调用sleep方法后,线程进入计时等待状态,调用yield方法后,线程进入就绪状态.
4):不同点——两方法开发中用途不同：sleep()方法开发中更多的用于模拟延迟,让多线程并发访问同一个资源的错误效果更明显.；yield()方法开发中很少会使用到该方法，该方法主要用于调试或测试，它可能有助于因多线程竞争条件下的错误重现现象。
五、后台线程
5.1 引子：后台线程
Java中，前台线程创建的线程默认是前台线程（可以通过setDaenon(true)方法设置为后台线程），后台线程创建的线程默认是后台线程。由于main线程是一个前台线程，所以我们新建的线程默认都是前台线程，本节阐述Java线程另一种线程——后台线程。
注意1：设置后台线程：thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
注意2：前台线程停止，后台线程也停止，即使是finally块的内容也不执行了，且见本节代码演示。
注意3：main线程是前台线程
5.2 前台线程与后台线程
代码1——前台线程停止，后台线程也停止：
package mypackage;
public class Test {
public static void main(String[] args) {
Thread daemonThread = new Thread(new DaemonThread());
daemonThread.setDaemon(true); // thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
daemonThread.start();
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(500);
// mainThread中每次休眠比后台线程少，这个mainThread就比后台线程先结束，从而证明前台线程结束后后台线程也会结束
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("This is mainThread");
}
}
}
class DaemonThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("This is DaemonThread");
}
}
}输出1：
This is mainThread
This is DaemonThread
This is mainThread
This is mainThread
This is DaemonThread
This is mainThread
This is mainThread
小结1：该程序（即代码1）充分说明了，前台线程停止，那么它创建的后台线程也停止，但是如果是后台线程中finally块里面的内容，会任何时候都得到执行吗？且看代码2。
代码2——前台线程停止，后台线程也停止，即使是finally块的内容也不执行了：
package mypackage2;
public class Test {
public static void main(String[] args) {
Thread daemonThread = new Thread(new DaemonThread());
daemonThread.setDaemon(true); // thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
daemonThread.start();
}
}
class DaemonThread implements Runnable {
@Override
public void run() {
try {
System.out.println("This is DaemonThread");
} finally {
System.out.println("This is finally Blocks");
}
}
}
输出2：
This is DaemonThread
小结2：该程序（代码2）有三种输出情况：
第一，为空，什么都不输出，这是问题在后台线程尚未打印This is DaemonThread，主线程就结束了；
第二，输出为This is DaemonThread\n This is finally Blocks ,这是因为后台线程完全打印完后，主线程才结束；
第三，输出为This is DaemonThread，这是因为后台线程尚未执行完，finally中的代码未执行完，主线程结束。
我们重点谈论第三种输出，这一个输出可以充分说明，后台线程中即使是finally块中的语句，也不一定会得到执行。这与我们的认知的是矛盾的，通常来说，finally块的语句一定会得到执行，所以开发的时候一般将jdbc连接的close或io的close放在finally块里面。
原因简单阐述，这是因为main()退出时，JVM就会立即关闭所有的后台进场，并不会有任何你希望出现的确认形式。
解决方法，只能让程序员自己来解决这个问题，写程序的时候，要慎用后台线程，如代码2，若将main()中setDaemon()注释掉，就永远可以看到finally子句的执行，所有要慎用后台线程，否则finally子句将不再安全。
5.3 后台线程：小结
后台线程最重要的点就是生命周期跟随创建它的前台线程，前台线程死亡，后台线程立刻死亡，即使是finally中的子句也不一定会执行。
六、联合线程
6.1 引子：联合线程
定义：Java中，联合线程使用join()方法实现，线程的join方法表示一个线程等待另一个线程完成后才执行。join方法被调用之后，线程对象处于阻塞状态。 有人也把这种方式称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程，且见本节代码。
6.2 联合线程代码演示
代码1：
package mypackage;
public class Test {
public static void main(String[] args) throws InterruptedException {
Thread joinThread = new Thread(new JoinThread());
for (int i = 0; i < 5; i++) {
System.out.println("main :" + i);
if (i == 1) {
joinThread.start();
}
if (i == 3) {
joinThread.join(); // 强制运行joinThread,main线程被设置为阻塞状态
}
}
}
}
class JoinThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("JoinThread: " + i);
}
}
}
输出1：
main :0
main :1
main :2
main :3
JoinThread: 0
JoinThread: 1
JoinThread: 2
JoinThread: 3
JoinThread: 4
main :4
小结：join()方法就用阻塞当前正在运行的线程（代码1中为main线程），运行新建加入的线程（代码1中的JoinThread）,等到JoinThread运行完之后再运行mian线程。可以更加简单的理解，就是在main线程中嵌入一个JoinThread线程。
6.3 联合线程：小结
联合线程就是在某线程（代码1中main线程）中嵌入一个新线程（代码1中JoinThread），然后运行的时候当然是按照嵌入的运行。
七、小结
本文介绍Java线程相关知识，包括：线程生命周期、线程优先级、线程礼让、后台线程、联合线程，基本涵盖Java多线程部分的各个常用知识点，希望对初学者学习者提供帮助。
天天打码，天天进步！
