控制线程join、后台线程、优先级

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 InterruptedException {
		//启动子线程
		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);
		}
	}
	
}

结果: main线程执行到 20 的时候就等待 jt 执行完成后才执行 ，“新线程” 不受影响，

结论:当在某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到被 join() 方法加入的 join 线程执行完为止。

• join() 方法如下三种重载形式
  1. join() 等待被 join() 的线程执行完成
  2. join(long millis): 等待被 join 的线程的时间最长为 millis 毫秒。如果在 millis 毫秒内被 join 的线程还没有执行结束，则不再等待。
  3. join(long millis, int manos): 等待被 join 的线程的时间最长为 millis 毫秒 加 manos 微秒。

第 3 种不推荐，因为计算机硬件、操作系统本身也无法精确到毫秒。(程序对时间的精度无须精确到微秒)。

join() 方法文档解释是 ：等待这个线程死亡。
意思就是哪个线程调用 join() 方法，调用join方法的线程 就会一路到底执行完成直至死亡，当此句所在的 线程会一直阻塞直到它(调用join()的线程)完成。（对于无参的这个方法而已）

后台线程

• 有一种线程，它是后台运行的，它的任务是为其他的线程提供服务，这种线程被 称为“后台线程”，又被称为“守护线程” 或 “精灵线程”. JVM 的垃圾回收线程就是典型的后台线程。

• 后台线程有个特性： 如果所有的前台线程都死亡， 后台线程会自动死亡。

• 调用 Thread 对象的 setDaemon(true) 方法可将指定线程设置成后台线程。

• 当所有的前台线程死亡时，后台线程随之死亡。当整个虚拟机中只剩下后台线程时，程序就没有继续运行的必要了，所以虚拟机也就退出了。

public class DaemonThread extends Thread {
	
	//Daemon 后台
	//定义后台线程的线程执行体 与 普通线程没有任何区别
	
	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 线程)结束——
		//后台线程也应该随之结束
		
	}

}

上面程序结果发现：后台线程无法运行到 999 是因为当主线程也就是程序中的唯一前台线程运行结束后，JVM 会主动退出，因而后台线程也就被结束了。

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

• 注意点：

  1. 主线程默认是前台线程，并不是所有的线程默认都是前台线程，有些线程默认就是后台线程
     ——前台线程创建的子线程默认就是前台线程，后台线程创建的子线程默认是后台线程。

  2. 前台线程死亡后，JVM 会通知后台线程死亡，但从它接收指令到做出响应，需要一定时间。

  3. 要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是 setDaemon(true) 必须在 start() 之前调用，否则会引发 IllegalThreadStateException 异常。

线程睡眠： sleep

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

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

• 另外一种涉及微秒，情况与前面类似，基本不用。

当 当前线程调用 sleep() 方法进入阻塞状态后， 在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于 sleep() 中的线程也不会执行，因此 sleep() 方法通常用来暂停程序的执行。

 //简单的例子:
 for(int i = 0; i < 10; i ++){
 	System.out.println("当前时间: " + new Date() );
 	//调用 sleep() 方法让当前线程暂停 1s
 	Thread.sleep(1000);
 }

结果： 输出第一次后当前时间: 暂停1秒后再次重复执行。

此外， Thread 还提供了一个与 sleep() 方法有点相试的 yield() 静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。yield() 只是让当前线程暂停一下，让系统的线程调度器重新调度一次，
完全可能：当某个线程调用了 yield() 方法暂停之后，线程调度器又将其调度出来重新执行。

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

  1. sleep() 方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但 yield() 方法只会给优先级相同，或优先级更高的线程执行体机会。 (因为 yield() 是让线程进入就绪状态)

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

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

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

改变线程优先级

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

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

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

1. MAX_PRIORITY: 值是10；
2. MIN_PRIORITY: 值是1；
3. NORM_PRIORITY: 其值是 5； 标准的

注意：子线程 与 创建它的父线程拥有相同的优先级，优先级高的线程获得更多执行机会。

内容摘取 《疯狂 Java 讲义》 自己当笔记用的