java 设置线程级别_【Java并发001】使用级别：线程相关知识全解析

一、前言

本文介绍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 终止状态(进入终止状态后只能结束，无法再返回回来)

关于状态之间的转换图，我认为这张图最能符合标准：

image.png

补充：因为可运行状态Runnable包括Ready就绪状态和Running运行状态，但是就绪状态进入运行状态是CPU调度，程序员无法控制，所本文中对这两种状态不做区分，统一为可运行状态，两者中转换如图：

image.png

问题(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 DaemonThreadn 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多线程部分的各个常用知识点，希望对初学者学习者提供帮助。

天天打码，天天进步！