这是一个来自 Java 编程思想的例子，它只是想表达 sleep 的线程可中断，但同步 IO 等待资源，或同步获得锁失败的线程，是不可同步的。

//: concurrency/Interrupting.java

// Interrupting a blocked thread.

import java.util.concurrent.*;

import java.io.*;

import static net.mindview.util.Print.*;

class SleepBlocked implements Runnable {

public void run() {

try {

TimeUnit.SECONDS.sleep(100);

} catch(InterruptedException e) {

print("InterruptedException");

}

print("Exiting SleepBlocked.run()");

}

}

class IOBlocked implements Runnable {

private InputStream in;

public IOBlocked(InputStream is) { in = is; }

public void run() {

try {

print("Waiting for read():");

in.read();

} catch(IOException e) {

if(Thread.currentThread().isInterrupted()) {

print("Interrupted from blocked I/O");

} else {

throw new RuntimeException(e);

}

}

print("Exiting IOBlocked.run()");

}

}

class SynchronizedBlocked implements Runnable {

public synchronized void f() {

while(true) // Never releases lock

Thread.yield();

}

public SynchronizedBlocked() {

new Thread() {

public void run() {

f(); // Lock acquired by this thread

}

}.start();

}

public void run() {

print("Trying to call f()");

f();

print("Exiting SynchronizedBlocked.run()");

}

}

public class Interrupting {

private static ExecutorService exec =

Executors.newCachedThreadPool();

static void test(Runnable r) throws InterruptedException{

Future> f = exec.submit(r);

TimeUnit.MILLISECONDS.sleep(100);

print("Interrupting " + r.getClass().getName());

f.cancel(true); // Interrupts if running

print("Interrupt sent to " + r.getClass().getName());

}

public static void main(String[] args) throws Exception {

test(new SleepBlocked());

test(new IOBlocked(System.in));

test(new SynchronizedBlocked());

test(new Runnable() { //自己写的测试线程

@Override

public void run () {

System.out.println("1 start run");

try {

new Object().wait(); //这句不抛异常，为什么？

} catch (InterruptedException e) {

System.out.println("1 catch InterruptedException");

e.printStackTrace();

}

System.out.println("1 exit run");

}

});

TimeUnit.SECONDS.sleep(3);

print("Aborting with System.exit(0)");

new Object().wait(); //这句抛异常

System.exit(0); // ... since last 2 interrupts failed

}

}

打印结果：

Interrupting SleepBlocked

Interrupt sent to SleepBlocked

InterruptedException

Exiting SleepBlocked.run()

Waiting for read():

Interrupting IOBlocked

Interrupt sent to IOBlocked

Trying to call f()

Interrupting SynchronizedBlocked

Interrupt sent to SynchronizedBlocked

1 start run

Interrupting Interrupting$1

Interrupt sent to Interrupting$1 //而且看起来，中断也没起作用？(如果有作用，之后应该出现这个线程的打印结果)

Aborting with System.exit(0)

Exception in thread "main" java.lang.IllegalMonitorStateException

at java.lang.Object.wait(Native Method)

at java.lang.Object.wait(Object.java:502)

at Interrupting.main(Interrupting.java:92)

我知道 wait 正确用法是在同步方法或同步块中使用，

所以现在问题有 2 个，

为啥主函数的 new Object().wait();抛 IllegalMonitorStateException 异常，我自创的线程却没有抛出 IllegalMonitorStateException 异常呢？

从打印结果，我那个线程真的 wait 了(因为只打印出来一句)。但为啥中断它时，还是没有反应呢？

test(new Runnable() {

@Override

public void run () {

synchronized(this) {

System.out.println("1 start run");

try {

wait();

} catch (InterruptedException e) {

System.out.println("1 catch InterruptedException");

e.printStackTrace();

}

System.out.println("1 exit run");

}

}

});

然后我试了上面这个版本的，打印结果如下：

Interrupting SleepBlocked

Interrupt sent to SleepBlocked

InterruptedException

Exiting SleepBlocked.run()

Waiting for read():

Interrupting IOBlocked

Interrupt sent to IOBlocked

Trying to call f()

Interrupting SynchronizedBlocked

Interrupt sent to SynchronizedBlocked

1 start run

Interrupting Interrupting$1

Interrupt sent to Interrupting$1

1 catch InterruptedException

java.lang.InterruptedException

at java.lang.Object.wait(Native Method)

at java.lang.Object.wait(Object.java:502)

at Interrupting$1.run(Interrupting.java:75)

at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)

at java.util.concurrent.FutureTask.run(FutureTask.java:266)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)

at java.lang.Thread.run(Thread.java:745)

1 exit run

Aborting with System.exit(0)

Exception in thread "main" java.lang.IllegalMonitorStateException

at java.lang.Object.wait(Native Method)

at java.lang.Object.wait(Object.java:502)

at Interrupting.main(Interrupting.java:86)

所以，wait 之前是获得锁的情况，才可以被中断呗？