juc-02-interrupt()、join()、yield()和守护线程

这篇文章，给大家介绍一下 Thread 类的进阶知识，介绍并演示 interrupt()、join()、yield()的作用，还有守护线程的特点。

• 自然执行完
• 抛出未处理异常

• stop()：强制结束线程，会导致线程不会正确释放资源，
• suspend()：挂起，线程不会释放资源，容易导致死锁。

注意： java线程是 协作式，而非抢占式
合理方式： 应该调用一个线程的 interrupt() 方法中断一个线程，并不是强行关闭这个线程，只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。

一般情况是： 我们在当前线程的run()方法中，判断当前线程的中断状态是否为true，进而决定是否退出当前线程的运行。

Thread的sleep()、join()和Object的wait()方法，都能够抛出InterruptedException。
interrupt()方法只是将线程的中断标志位置为true，sleep()、join() 、wait()会不断检查线程的中断状态，如果当前线程中断标识位为ture，则会抛出InterruptEdException。

注意： 线程抛出InterruptEdException后，清空此线程的中断状态，也就是说，将此线程设置为非中断状态，中断标识设置为false。
抛出的InterruptEdException被catch后，再调用isInterrupted()，会返回false。

• interrupt()：只是将线程的中断标志位置为true，并不是强行关闭这个线程，线程是否中断，由线程本身决定。
• isInterrupted()：判断此线程是否已处于中断状态，此方法不影响线程的中断状态。
• interrupted()：静态方法，获取当前线程的中断状态，不管当前线程中断状态如何，接着清空当前线程的中断状态。

    @Test
    public void testInterrupt() throws InterruptedException {
 // 演示 interrupt() 、 isInterrupted() 和 InterruptedException
 Thread thread = new Thread(new Runnable() {
     @Override
     public void run() {
  DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  System.out.println("子线程开始执行任务..." + formatter.format(LocalDateTime.now()));
  // 如果当前线程不处于中断状态，则每秒打印当前时间
  while (!Thread.currentThread().isInterrupted()) {
      try {
   // sleep() 方法会检测线程的中断状态，如果已中断，则抛出InterruptedException
   TimeUnit.SECONDS.sleep(1);
   System.out.println("打印当前时间：" + formatter.format(LocalDateTime.now()));
      } catch (InterruptedException e) {
   System.out.println("catch InterruptedException：" + e.getMessage());
   // InterruptedException 会清空中断状态，所以此时的中断状态为 false
   System.out.println("当前线程中断状态：" + Thread.currentThread().isInterrupted());
//   e.printStackTrace();
   // InterruptedException 会清空中断状态，需要再次执行interrupt()，才能将线程状态置为已中断，退出循环
   Thread.currentThread().interrupt();
      }
  }
  System.out.println("子线程任务结束..." + formatter.format(LocalDateTime.now()));
     }
 });
 thread.start();
 TimeUnit.SECONDS.sleep(3);
 System.out.println("主线程执行子线程的interrupt()");
 // 只是将线程的中断标志位置为true，并不是强行关闭这个线程，线程是否中断，由线程本身决定。
 thread.interrupt();
    }

子线程开始执行任务...2020-09-17 18:18:44
打印当前时间：2020-09-17 18:18:45
打印当前时间：2020-09-17 18:18:46
主线程执行子线程的interrupt()
catch InterruptedException：sleep interrupted
当前线程中断状态：false
子线程任务结束...2020-09-17 18:18:47

    @Test
    public void testInterrupted() throws InterruptedException {
 // 演示 interrupted()
 Thread thread = new Thread(new Runnable() {
     @Override
     public void run() {
  // 静态方法 Thread.interrupted() 获取当前线程的中断状态，不管当前线程中断状态如何，接着清空当前线程的中断状态
  System.out.println("静态方法 Thread.interrupted() 获取当前线程的中断状态：" + Thread.interrupted() + "，然后清空中断状态");
  System.out.println("成员方法 interrupted() 获取当前线程的中断状态："+Thread.currentThread().interrupted());
  DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  System.out.println("子线程开始执行任务..." + formatter.format(LocalDateTime.now()));
  // 如果当前线程不处于中断状态，则每秒打印当前时间
  if (!Thread.currentThread().isInterrupted()) {
      System.out.println("打印当前时间：" + formatter.format(LocalDateTime.now()));
  }
  System.out.println("子线程任务结束..." + formatter.format(LocalDateTime.now()));
     }
 });
 thread.start();
 thread.interrupt();
 TimeUnit.SECONDS.sleep(3);
    }

静态方法 Thread.interrupted() 获取当前线程的中断状态：true，然后清空中断状态
成员方法 interrupted() 获取当前线程的中断状态：false
子线程开始执行任务...2020-09-17 18:20:13
打印当前时间：2020-09-17 18:20:13
子线程任务结束...2020-09-17 18:20:13

public class TestJoin {

    @Test
    public void testJoin() throws InterruptedException {
 // 演示 join() 方法使用
 //线程自然死亡(结束)：自然执行完或者抛出未处理异常

 // main线程开始运行
 System.out.println(Thread.currentThread().getName() + "开始运行...");
 // t1 不需要等待其他线程运行结束
 JoinThread t1 = new JoinThread("t1", null);
 // t2 线程等待 t1 线程死亡，再继续往下运行
 JoinThread t2 = new JoinThread("t2", t1);
 // t3 线程等待 t2 线程死亡，再继续往下运行
 JoinThread t3 = new JoinThread("t3", t2);
 // t4 线程等待 t3 线程死亡，再继续往下运行
 JoinThread t4 = new JoinThread("t4", t3);

 t1.start();
 t2.start();
 t3.start();
 t4.start();
 // main线程等待 t4 线程死亡，再继续往下运行
 t4.join();
 System.out.println(Thread.currentThread().getName() + "继续运行");
 System.out.println(Thread.currentThread().getName() + "运行结束...");
    }
}

//自定义线程类
class JoinThread extends Thread {

    // previousThread：前一个线程
    // 当前线程等待 previousThread 运行结束再继续运行
    private Thread previousThread;

    public JoinThread(String name, Thread previousThread) {
 super(name);
 this.previousThread = previousThread;
    }

    @Override
    public void run() {
 if (this.previousThread != null) {
     System.out.println(Thread.currentThread().getName() + "调用" + this.previousThread.getName() + ".join()，等待" + this.previousThread.getName() + "死亡");
     try {
  // 当前线程等待 previousThread 运行结束再继续运行
  this.previousThread.join();
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName() + "继续运行");
 }
 try {
     // sleep 2 秒，模拟业务执行花了2秒
     TimeUnit.SECONDS.sleep(2);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }
 System.out.println(Thread.currentThread().getName() + "运行结束...");
    }
}

main开始运行...
t2调用t1.join()，等待t1死亡
t4调用t3.join()，等待t3死亡
t3调用t2.join()，等待t2死亡
t1运行结束...
t2继续运行
t2运行结束...
t3继续运行
t3运行结束...
t4继续运行
t4运行结束...
main继续运行
main运行结束...

    @Test
    public void testJoinWithTimeOut() throws InterruptedException {
 // 演示 join(long millis) 方法使用: 设置等待的超时时间，阻塞等待此线程死亡(运行结束)，若超时时间为0，则一直等待直到此线程死亡。

 // main线程开始运行
 System.out.println(Thread.currentThread().getName() + "开始运行...");
 Thread thread = new Thread(()->{
     System.out.println(Thread.currentThread().getName() + "开始运行...");
     try {
  // sleep 5 秒，模拟业务执行花了5秒
  TimeUnit.SECONDS.sleep(5);
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName() + "结束...");

 });
 thread.start();
 // join()，阻塞等待 thread 运行结束，设置超时时间为 3000 ms
 thread.join(3000);
 System.out.println(Thread.currentThread().getName() + "继续运行");
 System.out.println(Thread.currentThread().getName() + "运行结束...");
 TimeUnit.SECONDS.sleep(3);
    }

main开始运行...
Thread-0开始运行...
main继续运行
main运行结束...
Thread-0结束...

public class TestYield {

    @Test
    public void testYield() throws InterruptedException {
 // 演示 yield() 方法使用
 Thread t1 = new Thread(new Runnable() {
     @Override
     public void run() {
  for (int i = 0; i < 5; i++) {
      if (i == 2) {
   System.out.println(Thread.currentThread().getName() + "--> " + i + " -- yield");
   // yield()：线程让出CPU，变成就绪状态
   Thread.currentThread().yield();
      }else
   System.out.println(Thread.currentThread().getName() + "--> " + i);
  }
     }
 }, "t1");
 Thread t2 = new Thread(new Runnable() {
     @Override
     public void run() {
  for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + "=== " + i);
  }
     }
 }, "t2");
 t1.start();
 t2.start();
 TimeUnit.MILLISECONDS.sleep(1500);
    }
}

t1--> 0
t1--> 1
t1--> 2 -- yield
t2=== 0
t2=== 1
t2=== 2
t2=== 3
t2=== 4
t1--> 3
t1--> 4

public class TestDaemon {

    @Test
    public void testDaemon() throws InterruptedException {
 // 演示 setDaemon()、isDaemon() 方法使用
 Thread t1 = new Thread(new Runnable() {
     @Override
     public void run() {
  try {
      //判断当前线程是不是守护线程
      System.out.println(Thread.currentThread().getName() + "是守护线程: " + Thread.currentThread().isDaemon());
      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
      // 如果当前线程不处于中断状态，则每秒打印当前时间
      while (!Thread.currentThread().isInterrupted()) {
   try {
// sleep() 方法会检测线程的中断状态，如果已中断，则抛出InterruptedException
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + " 打印当前时间：" + formatter.format(LocalDateTime.now()));
   } catch (InterruptedException e) {
e.printStackTrace();   
// InterruptedException 会清空中断状态，需要再次执行interrupt()，才能将线程状态置为已中断，退出循环
Thread.currentThread().interrupt();
   }
      }
      System.out.println(Thread.currentThread().getName() + " 任务结束..." + formatter.format(LocalDateTime.now()));
  } finally {
      System.out.println(Thread.currentThread().getName() + "执行 finlly 代码块");
  }
     }
 }, "t1");
 //设置为守护线程，在start()方法之前调用才有效
 t1.setDaemon(true);
 t1.start();
 TimeUnit.MILLISECONDS.sleep(3000);
    }
}

t1是守护线程: true
t1 打印当前时间：2020-09-18 11:08:52
t1 打印当前时间：2020-09-18 11:08:53