[Java] 详解Java 线程中断

new Thread(new Runnable(
 @Override
 public void run() {
  // todo sth...
 }
)).start();

• 设置一个标志位：true / false 来退出；
  
• 强制退出：thread.stop；（我相信，现在应该没人会使用这种方式了，因为JDK也很早就废弃了该方法）
  

This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it 
has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the 
objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to 
other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply 
modifies some variable to indicate that the target thread should stop running. The target thread should check this
variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop 
running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method 
should be used to interrupt the wait.

**Thread.stop 方法天生就不安全。**使用该方法来停止线程，将会导致其它因为监视器锁『监视器我们在 synchronized 中就讲过，是 Java 的内置锁』而被锁住的线程全部都解锁！（本质的后果是：没有检查的 ThreadDeath 异常会在栈中传播，因而使得监视器锁解锁）。如果任何一个被监视器锁给锁住的对象处于一个不一致的状态，那么其被解锁后将会被其它线程可见，潜在的结果是产生任何后果。**我们应该使用一个变量来代替使用 stop 方法，告诉目标线程退出『这里就是我们开头所说的第一种方法，设置一个标志位』。**目标线程应该周期性的检查这个变量，并根据这个变量来正确的退出 run 方法。如果目标线程处于阻塞/休眠状态（如：使用 wait、sleep、yield 方法后，线程让出了 CPU 使用权，进而阻塞/休眠），此时，该标志位变量将不会起作用，那么，应该使用 interrupt 方法来中断目标线程的阻塞/休眠状态，将其唤醒！

• 线程可以在几乎任何地方抛出 ThreadDeath 异常。由于这一点，所有的同步方法和（代码）块将必须被考虑得事无巨细。
  
• 线程在清理第一个 ThreadDeath 异常的时候（在 catch 或 finally 语句中），可能会抛出第二个。清理工作将不得不重复直到到其成功。保障这一点的代码将会很复杂。
  

• 使用suspend时，并不会释放锁；
  
• 如果存在某种情况要先获取该锁，再进行resume，那么就造成死锁了；
  
• 
  

因为 Object.wait 进入阻塞时，会释放锁。

• 成员方法 interrupt()：设置线程中断标志为 true ；
  
• 成员方法 isInterrupted()：获取线程的中断状态，默认为 false，调用 interrupt() 后，该方法返回 true；
  
• 静态方法 Thread.interrupted()：获取线程的中断状态，并且清除中断状态（设置为 false）；
  

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread running...");
  }
 }
 
 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");
 
  System.out.println("start thread");
  thread.start();
 
  Thread.sleep(50);
  System.out.println("interrupt thread");
  thread.interrupt();
 
  Thread.sleep(50);
  System.out.println("thread's status = " + thread.isInterrupted());
 }
}

start thread
Thread running...
Thread running...
......
interrupt thread
Thread running...
Thread running...
......
thread's status = true
Thread running...
......

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
  Thread.sleep(10000);
   } catch (InterruptedException e) {
  System.out.println("thread interrupted...");
   }
 
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
 }
 
 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");
 
  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
thread interrupted...
Thread run, total sleep = 3002(ms)
Thread will sleep 10s ------------------------- running
Thread run, total sleep = 10002(ms)
Thread will sleep 10s ------------------------- running

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);
 
 @Override
 public void run() {
  while (running.get()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }
 
 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");
 
  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  running.set(false);
  System.out.println("main exit");
 }
}

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (!Thread.currentThread().isInterrupted()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }
 
 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");
 
  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);
 
 @Override
 public void run() {
  while (running.get()) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
  Thread.sleep(10000);
   } catch (InterruptedException e) {
  System.out.println("Interrupted... Todo other things then exit......");
  running.set(false);
  continue;
   }
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }
 
 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");
 
  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
Interrupted... Todo other things then exit......
Thread exit

• Object.wait：阻塞当前线程，释放持有的锁；
  
• Object.notify：唤醒当前对象上被阻塞的线程，使其进入就绪状态；
  
• Object.notifyAll：唤醒所有线程；
  
• Thread.sleep：指定当前线程休眠一定时间，让出CPU，但不会释放同步资源锁；
  
• Thread.yield：让出CPU使用权，让自己和其它线程来争夺使用CPU的机会，因此，使用此方法后，并不能保证该线程又再次拿到CPU而恢复运行（使用此方法后，优先级高的线程拿到CPU的概率较大，但优先级低的线程也有概率拿到CPU而执行），同理不会释放同步资源锁；