join() 线程
Thread 提供了让一个线程等待另一个线程完成的方法 —— join() 方法。当在某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到被 join() 方法加入的 join 线程执行完为止。
join() 方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作。
public class JoinThread extends Thread {
// 提供一个有参数的构造器，用于设置该线程的名字
public JoinThread(String name) {
super(name);
}
// 重写run()方法，定义线程执行体
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) throws Exception {
// 启动子线程
Thread th =new JoinThread("新线程");
th.start();
// th.join(); // main函数会等待th线程执行完成再开始执行，执行到19进入执行jt线程
for (int i = 0; i < 100; i++) {
if (i == 20) {
JoinThread jt = new JoinThread("被Join的线程");
jt.start();
// main线程调用了jt线程的join()方法，main线程
// 必须等jt执行结束才会向下执行
jt.join();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
不添加 th.join()，主线程（main）会与名为 “新线程”的子线程并发执行当主线程的循环变量 i 等于 20 时，启动名为“被Join的线程”的线程，该线程不会和 main 线程并发执行，main 线程必须等待该线程执行完成后才可以向下执行。而此时“新线程”与其并发执行。
join() 方法有如下三种重载形式：
- join()：等待被 join 的线程执行完成；
- join(long millis)：等待被 join 的线程时间最长为 millis 毫秒。如果在 millis 毫秒被 join 的线程还没有执行结束，则不再等待。
- join(long millis, int nanos)：等待被 join 的线程的时间最长为 millis 毫秒加 nanos 毫微秒。
通常很少使用第三种形式，原因有两个：程序对时间的精度无须精确到微毫秒；计算机硬件、操作系统本身也无法精确到毫微秒。
后台线程
有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又称为“守护线程” 或 “精灵线程”。JVM 的垃圾回收线程就是典型的后台线程。
后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。
调用 Thread 对象的 setDaemon(true)方法可将指定线程设置成后台线程。
public class DaemonThread extends Thread {
// 定义后台线程的线程执行体与普通线程没有任何区别
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
DaemonThread t = new DaemonThread();
// 将此线程设置成后台线程
t.setDaemon(true);
// 启动后台线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
// -----程序执行到此处，前台线程（main线程）结束------
// 后台线程也应该随之结束
}
}
Thread 类还提供了一个
isDaemon()方法，用于判断指定线程是否为后台线程。
主线程默认是前台线程，t线程默认也是前台线程。并不是所有的线程默认都是前台线程，有些线程默认就是后台线程 —— 前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。
前台线程死亡后，JVM 会通知后台线程死亡，但从它接受指令到做出响应，需要一定时间。而且要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是说，setDaemon(true) 必须在 start() 方法之前调用，否则会引发 IllegalThreadStateException。
线程睡眠：sleep
如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用 Thread 类的静态 sleep() 方法来实现。sleep() 方法有两种重载形式：
- static void sleep(long millis)：让当前正在执行的线程暂停 millis 毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
- static void sleep(long millis, int nanos)：让当前正在执行的线程暂停 millis 毫秒加 nanos 毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
当线程调用 sleep() 方法进入阻塞状态后，在其睡眠时段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于 sleep() 中的线程也不会执行，因此 sleep() 方法常用来暂停程序的执行。
public class SleepTest{
public static void main(String[] args) throws Exception{
for (int i = 0; i < 10 ; i++ ){
System.out.println("当前时间: " + new Date());
// 调用sleep方法让当前线程暂停1s。
Thread.sleep(1000);
}
}
}
线程让步：yield
与sleep() 方法类似，是Thread的静态方法，也可以让当前正在执行的线程暂停，但它不会阻塞线程，只会将线程转入就绪状态。yield() 只是让当前线程暂停一下，让系统的调度器重新调度一次，完全可能的情况是：当某个线程调用了 yield() 方法暂停之后，线程调度器又将其调度出来重新执行。
当线程调用了 yield() 方法暂停之后，只有优先级与当前线程相同，或者更高的处于就绪状态的线程才会获得执行的机会。
public class YieldTest extends Thread{
public YieldTest(String name) {
super(name);
}
// 定义run方法作为线程执行体
public void run() {
for (int i = 0; i < 50 ; i++ ) {
System.out.println(getName() + " " + i);
// 当i等于20时，使用yield方法让当前线程让步
if (i == 20) {
Thread.yield(); ❶
}
}
}
public static void main(String[] args)throws Exception {
// 启动两条并发线程
YieldTest yt1 = new YieldTest("高级");
// 将ty1线程设置成最高优先级
// yt1.setPriority(Thread.MAX_PRIORITY); ❷
yt1.start();
YieldTest yt2 = new YieldTest("低级");
// 将yt2线程设置成最低优先级
// yt2.setPriority(Thread.MIN_PRIORITY); ❸
yt2.start();
}
}
❶处调用 yield() 静态方法让当前正在执行的线程暂停，让系统线程调度器重新调度。❷❸处处于注释状态 —— 即两个线程的优先级完全一样，所以当一个线程试用 yield() 方法暂停后，另一个线程就会开始执行。
❷❸处注释取消后，由于高优先级线程调用 yield() 方法暂停之后，系统没有与之优先级相同的线程，或更高优先级的线程，所以该线程会继续执行。
在多 CPU 并行的环境下，yield() 方法的功能有时候并不明显，如果使用多 CPU 机器运行上面程序，则可能看不到上述现象。
关于 sleep()方法与 yield() 方法的区别如下：
- sleep() 方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但 yield() 方法只会给优先级相同，或优先级高的线程执行的机会。
- sleep() 方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而 yield() 不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用 yield() 方法暂停之后，立即再次获得处理器资源执行。
- sleep() 方法声明跑出了 InterruptedException 异常，所以调用 sleep() 方法时要么捕捉该异常，要么显式声明抛出该异常；而 yield() 方法则没有声明抛出任何异常。
- sleep() 方法比 yield() 方法有更好的可移植性，通常不建议使用 yield() 方法来控制并发线程的执行。
改变线程优先级
每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。
每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main 线程具有普通优先级，由 main 线程创建的子线程也具有普通优先级。
Thread 类提供了 setPriority(int newPriority)、 getPriority()方法来设置和返回指定线程的优先级，其中 setPriority() 方法的参数可以是一个整数，范围是 1~10 之间，也可以使用 Thread 类的如下三个静态常量。
- MAX_PRIORITY：其值是 10；
- MIN_PRIORITY：其值是 1；
- NORM_PRIORITY：其值是 5。
public class PriorityTest extends Thread {
// 定义一个有参数的构造器，用于创建线程时指定name
public PriorityTest(String name) {
super(name);
}
public void run() {
for (int i = 0 ; i < 50 ; i++ ) {
System.out.println(getName() + ",其优先级是："
+ getPriority() + ",循环变量的值为:" + i);
}
}
public static void main(String[] args) {
// 改变主线程的优先级
Thread.currentThread().setPriority(6);
for (int i = 0 ; i < 30 ; i++ ) {
if (i == 10) {
PriorityTest low = new PriorityTest("低级");
low.start();
System.out.println("创建之初的优先级:"
+ low.getPriority());
// 设置该线程为最低优先级
low.setPriority(Thread.MIN_PRIORITY);
}
if (i == 20) {
PriorityTest high = new PriorityTest("高级");
high.start();
System.out.println("创建之初的优先级:"
+ high.getPriority());
// 设置该线程为最高优先级
high.setPriority(Thread.MAX_PRIORITY);
}
}
}
}
打印结果：
创建之初的优先级:6
低级,其优先级是：6,循环变量的值为:0
低级,其优先级是：1,循环变量的值为:1
创建之初的优先级:6
高级,其优先级是：10,循环变量的值为:0
高级,其优先级是：10,循环变量的值为:1
高级,其优先级是：10,循环变量的值为:2
低级,其优先级是：1,循环变量的值为:2
高级,其优先级是：10,循环变量的值为:3
低级,其优先级是：1,循环变量的值为:3
高级,其优先级是：10,循环变量的值为:4
高级,其优先级是：10,循环变量的值为:5
高级,其优先级是：10,循环变量的值为:6
高级,其优先级是：10,循环变量的值为:7
高级,其优先级是：10,循环变量的值为:8
高级,其优先级是：10,循环变量的值为:9
高级,其优先级是：10,循环变量的值为:10
高级,其优先级是：10,循环变量的值为:11
高级,其优先级是：10,循环变量的值为:12
...
从打印结果可以看出：
- 子进程与创建它的父进程拥有相同的优先级
- 优先级高的线程获得更多的执行机会
虽然 Java 提供了 10 个优先级的级别，不同操作系统上的优先级并不相同，而且也不能很好的和 Java 的 10 个优先级对应，所以尽量避免直接为线程指定优先级，应该使用 MAX_PRIORITY、MIN_PRIORITY 和 NORM_PRIORITY 三个静态常量来设置优先级，这样可以保证程序具有最好的可移植性。
网友评论