并发（9）：终结任务（下）

傷城~ 2023-03-14 05:47 55阅读 0赞

**（1）被互斥所阻塞**

就像在Interrupting.java中看到的，如果你尝试着在一个任务上调用其synchronized方法，而这个对象的锁已经被其他任务获得，那么调用任务将被挂起（阻塞），直至这个锁可获得。下面的示例说明了同一个互斥可以如何能被同一个任务多次获得：

package concurrency;
    
    public class MultiLock {
    	public synchronized void f1(int count) {
    		if (count-- > 0) {
    			System.out.println("f1() calling f2() with count " + count);
    			f2(count);
    		}
    	}
    
    	public synchronized void f2(int count) {
    		if (count-- > 0) {
    			System.out.println("f2() calling f1() with count " + count);
    			f1(count);
    		}
    	}
    
    	public static void main(String[] args) {
    		final MultiLock multiLock = new MultiLock();
    		new Thread() {
    			public void run() {
    				multiLock.f1(10);
    			}
    		}.start();
    	}
    }

在main()中创建了一个调用f1()的Thread，然后f1()和f2()互相调用直至count变为0。由于这个任务已经在第一个对f1()的调用中获得了multiLock对象锁，因此同一个任务将在对f2()的调用中再次获得这个锁，依此类推。这么做是有意义的，因为一个任务应该能够调用在同一个对象中的其他的synchronized方法，而这个任务已经持有锁了。

就像前面在不可中断的I/O中所观察的那样，无论在任何时刻，只要任务以不可中断的方式被阻塞，那么都有潜在的会锁住程序的可能。java SE5并发类库中添加了一个特性，即在ReentrantLock上阻塞任务具备可以被中断的能力，这与在synchronized方法或临界区上阻塞的任务完全不同：

package concurrency;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    class BlockedMutex {
    	private Lock lock = new ReentrantLock();
    
    	public BlockedMutex() {
    		// 立即获取它，以演示中断
    		// 在ReentrantLock上阻塞的任务
    		lock.lock();
    	}
    
    	public void f() {
    		try {
    			// 这将永远不会用于第二个任务
    			lock.lockInterruptibly();
    			System.out.println("f()中获取的锁");
    		} catch (InterruptedException e) {
    			System.out.println("f()中的锁获取中断");
    		}
    	}
    }
    
    class Blocked2 implements Runnable {
    
    	BlockedMutex blocked = new BlockedMutex();
    
    	@Override
    	public void run() {
    		System.out.println("waiting for f() in BlockedMutex");
    		blocked.f();
    		System.out.println("断线了");
    	}
    }
    
    public class Interrupting2 {
    	public static void main(String[] args) throws InterruptedException {
    		Thread t = new Thread(new Blocked2());
    		t.start();
    		TimeUnit.SECONDS.sleep(1);
    		System.out.println("Issuing t.interrupt()");
    		t.interrupt();
    	}
    }

BlockedMutex类有一个构造器，它要获取所创建对象上自身的Lock，并且从不释放这个锁。出于这个原因，如果你试图从第二个任务中调用f()（不同于创建这个BlockedMutex的任务），那么将会总是因Mutex不可获得而被阻塞。在Blocked2中，run()方法总是在调用blocked.f()的地方停止。当运行这个程序时，你将会看到，与I/O调用不同，interrupt()可以打断被互斥所阻塞的调用。

### 四、检查中断 ###

注意，当你在线程上调用interrupt()时，中断发生的唯一时刻是在任务要进入到阻塞操作中，或者已经在阻塞操作内部时（如你所见，除了不可中断的I/O或被阻塞的synchronized方法之外，在其余的例外情况下，你无可事事）。但是如果根据程序运行的环境，你已经编写了可能会产生这种阻塞调用的代码，那又该怎么办呢？如果你只能通过在阻塞调用上抛出异常来退出，那么你就无法总是可以离开run()循环。因此，如果你调用interrupt()以停止某个任务，那么在run()循环碰巧没有产生任何阻塞调用的情况下，你的任务将需要第二种方式来退出。

这种机会是由中断状态来表示的，其状态可以通过调用interrupt()来设置。你可以通过调用interrupted()来检查中断状态，这不仅可以告诉你interrupt()是否被调用过，而且还可以清除中断状态。清除中断状态可以确保并发结构不会就某个任务被中断这个问题通知你两次，你可以经由的单一的InterruptedException或单一成功的Thread.interrupted()测试来得到这种通知。如果想要再次检查以了解是否被中断，则可以在调用Thread.interrupted()时将结果存储起来。

下面的示例展示了典型的惯用法，你应该在run()方法中使用它来处理在中断状态被设置时，被阻塞和不被阻塞的各种可能：

package concurrency;
    
    import java.util.concurrent.TimeUnit;
    
    class NeedsCleanup {
    	private final int id;
    
    	public NeedsCleanup(int ident) {
    		id = ident;
    		System.out.println("NeedsCleanup " + id);
    	}
    
    	public void cleanup() {
    		System.out.println("Cleaning up " + id);
    	}
    }
    
    class Blocked3 implements Runnable {
    
    	private volatile double d = 0.0;
    
    	@Override
    	public void run() {
    		try {
    			while (!Thread.interrupted()) {
    				NeedsCleanup n1 = new NeedsCleanup(1);
    				try {
    					System.out.println("Sleeping");
    					TimeUnit.SECONDS.sleep(1);
    					NeedsCleanup n2 = new NeedsCleanup(2);
    					try {
    						System.out.println("计算");
    						for (int i = 1; i < 2500000; i++) {
    							d = d + (Math.PI + Math.E) / d;
    						}
    						System.out.println("完成耗时的操作");
    					} finally {
    						n2.cleanup();
    					}
    				} finally {
    					n1.cleanup();
    				}
    			}
    			System.out.println("退出，通过while()测试");
    		} catch (InterruptedException e) {
    			System.out.println("退出，通过InterruptedException");
    		}
    	}
    }
    
    public class InterruptingIdiom {
    	public static void main(String[] args) throws InterruptedException {
    		Thread t = new Thread(new Blocked3());
    		t.start();
    		TimeUnit.MILLISECONDS.sleep(1100);
    		t.interrupt();
    	}
    }

NeedsCleanup类强调你经由异常离开循环时，正确清理资源的必要性。注意，所有在Blocked3.run()中创建的NeedsCleanup资源都必须在其后紧跟try-finally子句，以确保cleanup()方法总是会被调用。

你可以给程序提供一个命令行参数，来表示它在调用interrupt()之前以毫秒为单位的延迟时间。通过使用不同的延迟，你可以在不同地点退出Blocked3.run()：在阻塞的sleep()调用中，或者在非阻塞的数学计算中。你将看到，如果interrupt()在注释掉point2之后（即在非阻塞的操作过程中）被调用，那么首先循环将结束，然后所有本地对象将被销毁，最后循序会经由while语句的顶部退出。但是，如果interrupt()在point1和point2之间（在while语句之后，但是在阻塞操作sleep()之前或其过程中）被调用，那么这个任务就会在第一次试图调用阻塞操作之前，经由InterruptedException退出。在这种情况下，在异常被抛出之时唯一被创建出来的NeedsCleanup对象将被清除，而你也就有了catch子句中执行其他任何清除工作的机会。

被设计用来响应interrupt()的类必须建立一种策略，来确保它将保持一致的状态。这通常意味着所有需要清理的对象创建操作的后面，都必须紧跟try-finally子句，从而使得无论run()循环如何退出，清理都会发生。像这样的代码会工作的很好，但是，由于在java中缺乏自动的析构器调用，因此这将依赖于客户端程序员去编写正确的try-finally子句。

**如果本文对您有很大的帮助，还请点赞关注一下。**