Java--interrupt(),interrupted(),isInterrupted()

interrupt()

• public void interrupt()
• interrupt()方法用于线程中断，调用该方法的线程状态被置为“中断”状态。
• 注意：线程中断仅仅是置线程的中断状态位，不会停止线程。需要用户自己去监视线程的状态为并做处理。支持线程中断的方法（也就是线程中断后会抛出interruptedException的方法）就是在监视线程的中断状态，一旦线程的中断状态被置为“中断状态”，就会抛出中断异常。

• 代码示例：

  public class SimpleThreads {
  public static void main(String[] args) throws InterruptedException {
      // TODO Auto-generated method stub
      long patience = 1000 * 5;
  
      threadMessage("Starting MessageLoop thread");
      long startTime = System.currentTimeMillis();
      Thread t = new Thread(new MessageLoop());
      t.start();
  
      threadMessage("Waiting for MessageLoop thread to finish");
      while (t.isAlive()) {
          threadMessage("Still waiting...");
          // Wait maximum of 1 second
          // for MessageLoop thread
          // to finish.
          t.join(1000);
          if (((System.currentTimeMillis() - startTime) > patience)
                && t.isAlive()) {
              threadMessage("Tired of waiting!");
              t.interrupt();
              // Shouldn't be long now
              // -- wait indefinitely
              t.join();
          }
      }
      threadMessage("Finally!");
  }
  static void threadMessage(String message){
       String threadName = Thread.currentThread().getName();
       System.out.format("%s: %s%n", threadName, message);
  }
  private static class MessageLoop implements Runnable {
      public void run() {
          String importantInfo[] = {
              "Mares eat oats",
              "Does eat oats",
              "Little lambs eat ivy",
              "A kid will eat ivy too"
          };
          for (int i = 0; i < importantInfo.length; i++) {
              // Pause for 4 seconds
              try {
                  Thread.sleep(4000);
              } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  threadMessage("I wasn't done!");
                  threadMessage(Thread.currentThread().isInterrupted()+"");
              }
              // Print a message
              threadMessage(importantInfo[i]);
          }
      }
  }
  }

• 运行结果

  main: Starting MessageLoop thread
  main: Waiting for MessageLoop thread to finish
  main: Still waiting...
  main: Still waiting...
  main: Still waiting...
  main: Still waiting...
  Thread-0: Mares eat oats
  main: Still waiting...
  main: Tired of waiting!
  Thread-0: I wasn't done!
  Thread-0: false
  Thread-0: Does eat oats
  Thread-0: Little lambs eat ivy
  Thread-0: A kid will eat ivy too
  main: Finally!

interrupted()

• public static boolean interrupted()
• 测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

• 方法实现

  public static boolean interrupted() {
      return currentThread().isInterrupted(true);
  }

isInterrupted()

• public boolean isInterrupted()
• 测试线程是否已经中断。线程的中断状态 不受该方法的影响。

• 方法实现

  public boolean isInterrupted() {
      return isInterrupted(false);
  }

interrupted和isInterrupted主要区别

• interrupted（静态方法）是作用于当前正在运行的线程，Thread.interrupted()；isInterrupted是作用于调用某一线程，如线程t，t.isInterrupted()表示将线程t的中断位置为中断。
• 这两个方法都会调用同一个函数，只不过参数一个是true，一个是false
  
  • 该区别主要体现在方法参数上
  • private native boolean isInterrupted(boolean ClearInterrupted);
  • 如果这个参数为true，说明返回线程的状态位后，要清掉原来的状态位（恢复成原来情况）。这个参数为false，就是直接返回线程的状态位。

interrupt()和interrupted()比较

• interrupt（）是用来设置中断状态的。没有返回值，调用该方法后，线程被置为中断位，此时调用isInterrupted()返回为true，当线程中捕获到中断位异常后，线程中的中断状态会被自动清除，此时再调用isInterrupted()返回就是false了，示例见上面代码。
• interrupted是静态方法，返回的是当前线程的中断状态。例如，如果当前线程被中断（没有抛出中断异常，否则中断状态就会被清除），你调用interrupted方法，第一次会返回true。然后，当前线程的中断状态被方法内部清除了。第二次调用时就会返回false。如果你刚开始一直调用isInterrupted，则会一直返回true，除非中间线程的中断状态被其他操作清除了。