Java 学习之路 之 控制线程（七十五）

本文主要是介绍Java 学习之路 之 控制线程（七十五），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Java 的线程支持提供了一些便捷的工具方法，通过这些便捷的工具方法可以很好地控制线程的执行。

1，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{// 启动子线程new JoinThread("新线程").start();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);}}
}

上面程序中一共有 3 个线程，主方法开始时就启动了名为 “新线程” 的子线程，该子线程将会和 main 线程并发执行。当主线程的循环变量 i 等于 20 时，启动了名为 “被 Join 的线程” 的线程，该线程不会和 main 线程并发执行，main 线程必须等该线程执行结束后才可以向下执行。在名为 “被 Join 的线程” 的线程执行时，实际上只有 2 个子线程并发执行，而主线程处于等待状态。运行上面程序，会看到如图 16.5 所示的运行效果。

从图 16.5 中可以看出，主线程执行到 i == 20 时启动，并 join 了名为 “被 Join 的线程” 的线程，所以主线程将一直处于阻塞状态，直到名为 “被 Join 的线程” 的线程执行完成。

join() 方法有如下 3 种重载形式。

join()：等待被 join 的线程执行完成。

join(long millis)：等待被 join 的线程的时间最长为 millis 毫秒。如果在 millis 毫秒内被 join 的线程还没有执行结束，则不再等待。

join(long millis, int nanos)：等待被 join 的线程的时间最长为 millis 毫秒加 nanos 毫微秒。

通常我们很少使用第 3 种形式的方法，原因有两个：程序对时间的精度无须精确到毫微秒；计算机硬件、操作系统本身也无法精确到毫微秒。、

2，后台线程

有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为 “后台线程（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线程）结束------// 后台线程也应该随之结束}
}

上面程序中第 15 行代码先将t线程设置成后台线程，然后启动该线程，本来该线程应该执行到等于 i 等于 999 时才会结束，但运行程序时不难发现该后台线程无法运行到 999，因为当主线程也就是程序中唯一的前台线程运行结束后，JVM 会主动退出，因而后台线程也就被结束了。

Thread 类还提供了一个 isDaemon() 方法，用于判断指定线程是否为后台线程。

从上面程序可以看‘出，主线程默认是前台线程，t 线程默认也是前台线程。并不是所有的线程默认都是前台线程，有些线程默认就是后台线程——前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。

前台线程死亡后，JVM 会通知后台线程死亡，但从它接收指令到做出响应，需要定时间。而且要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是说 setDaemon(true) 必须在 start() 方法之前调用，否则会引发 IllegaIThreadStateException 异常。

3，线程睡眠：sleep

如果需要让当前正在执行的线程暂停一段时阿，并进入阻塞状态，则可以通过调用 Thread 类的静态 sleep() 方法来实现。sleep() 方法有两种重载形式。

static void sleep(long millis)：让当前正在执行的线程暂停 millis 毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。

static void sleep(long millis, int nanos)：让当前正在执行的线程暂停：millis 毫秒加 nanos 毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。 

与前面类似的是，程序很少调用第二种形式的 sleep() 方法。

当当前线程调用 sleep() 方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于 sleep() 中的线程也不会执行，因此 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);}}
}

上面程序中第 10 行代码将当前执行的线程暂停 1 秒，运行上面程序，看到程序依次输出 10 条字符串，输出 2 条字符串之间的时间间隔为 1 秒。

4，线程让步：yield

yield() 方法是一个和 sleep()方法有点相似的方法，它也是 Thread 类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。 yield() 只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当某个线程调用了 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();}
}

上面程序中的第 16 行代码调用 yield() 静态方法让当前正在执行的线程暂停，让系统线程调度器重新调度。由于程序中第 25 行、第 29 行代码处于注释状态——即两个线程的优先级完全一样，所以当一个线程使用 yield() 方法暂停后，另一个线程就会开始执行。运行上面程序，会看到如图 16.6 所示的运行结果。

如果将 YieldTest.java 程序中第 25 行、第 29 行代码的注释取消，也就是为两个绒程分别设置不同的优先级，则程序的运行结果如图 16.7 所示。

关于 sleep() 方法和 yield() 方法的区别如下。

sleep() 方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级：但 yield() 方法只会给优先级相同，或优先级更高的线程执行机会。

sleep() 方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而 yield() 不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用 yield() 方法暂停之后，立即再次获得处理器资源被执行。

sleep() 方法声明抛出了 InterruptedException 异常，所以调用 sleep() 方法时要么捕捉该异常，要么显式声明抛出该异常；而 yield() 方法则没有声明抛出任何异常。

sleep() 方法比 yield() 方法有更好的可移植性，通常不建议使用 yield() 方法来控制并发线程的执行。

5，改变线程优先级

每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。

每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main 线程具有普通优先级，由 main 线程创建的子线程也具有普通优先级。

Thread 类提供了 setPriority(int newPriority)、getPriority() 方法来设置和返回指定线程的优先级，其中 setPriority() 方法的参数可以是一个整数，范围是 1～10 之间，也可以使用 Thread 类的如下 3 个静态常量。

MAX_PRIORITY：其值是 10。

MIN_PRIORITY：其值是 1。

NORM_PRIORITY：其值是 5。

下面程序使用了 setPriority() 方法来改变主线程的优先级，并使用该方法改变了两个线程的优先级，从而可以看到高优先级的线程将会获得更多的执行机会。

public class PriorityTest extends Thread
{// 定义一个有参数的构造器，用于创建线程时指定namepublic 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);}}}
}

上面程序中的第 19 行代码改变了主线程的优先级为 6，这样由 main 线程所创建的子线程的优先级默认都是6，所以程序直接输出 Iow、high 两个线程的优先级时应该看到 6。接着程序将 low 线程的优先级设为 Priority.MIN_PRIORITY，将 high 线程的优先级设置为 Priority.MAX_PRIORITY。

运行上面程序，会看到如图 16.8 所示的效果。

值得指出的是，虽然 Java 提供了 10 个优先级级别，但这些优先级级别需要操作系统的支持。遗憾的是，不同操作系统上的优先级并不相同，而且也不能很好地和 Java 的 10 个优先级对应，例如 Windows 2000 仅提供了 7 个优先级。在这种情况下，我们应该尽量避免直接为线程指定优先级，而应该使用 MAX PRIORITY、MIN_PRIORITY 和 NORM_PRIORITY 三个静态常量来设置优先级，这样才可以保证程序具有最好的可移植性。

这篇关于Java 学习之路 之 控制线程（七十五）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---