并发（4）：基本的线程控制（下）

亦凉 2023-03-13 05:08 4阅读 0赞

### 十、术语 ###

正如前面各节所示，在java中，你可以选择如何实现并发编程，并且这个选择会令人困惑。这个问题通常来自于用来描述并发程序技术的术语，特别是设计线程的那些。

到目前为止，你应该看到要执行的任务与驱动它的线程之间有一个差异，这个差异在java类库中尤为明显，因为你对Thread类实际没有任何控制权（并且这种隔离在使用执行器时更加明显，因为执行器将替你处理线程的创建和管理）。你创建任务，并通过某种方式将一个线程附着到任务上，以使得这个线程可以驱动任务。

在java中，Thread类自身不执行任何操作，它只是驱动赋予它的任务，但是线程研究中总是不变的使用“线程执行这项或那项动作”这样的语言。因此，你得到的印象就是“线程就是任务”，当我第一次碰到java线程时，这种印象非常强烈，以至于我看到了一种明显的“是一个”关系，这就像是在说，很明显我应该从Thread继承出一个任务。另外，Runnable接口的名字选择很糟糕，所以我认为Task应该是好得多的名字。如果接口只是其方法的返型封装，那么“它执行能够做的事情”这种命名方式将是恰当的，但是如果它是要表示更高层次的抽象，例如Task，那么概念名将有用。

问题是各种抽象级别被混在了一起。从概念上讲，我们希望创建独立于其他任务运行的任务，因此我们应该能够定义任务，然后说“开始”，并且不用操心其细节。但是在物理上，创建线程可能会代价高昂，因此你必须保存并管理它们。这样从实现的角度看，将任务从线程中分离出来是很有意义的。另外，java的线程机制基于来自C的低级p线程方式，这是一种你必须深入研究，并且需要完全理解其所有事物的所有细节的方式。这种低级特性部分地渗入了java的实现中，因此为了处于更高的抽象级别，在编写代码时，你必须遵循规则（我将在本章中努力演示这些规则）。

为了澄清这些讨论，我将尝试着在描述将要执行的工作时使用术语“任务”，只有在我引用到驱动任务的具体机制时，才使用“线程”。因此，如果你在概念级别上讨论系统，那就可以只使用“任务”，而压根不需要提及驱动机制。

### 十一、加入一个线程 ###

一个线程可以在其他线程之上调用join()方法，其效果是等待一段时间直到第二个线程结束才继续执行。如果某个线程在另一个线程t上调用t.join()，此线程将被挂起，直到目标线程t结束才恢复（即t.isAlive()返回为假）。

也可以在调用join()时带上一个超时参数（单位可以是毫秒，或者毫秒和纳秒），这样如果目标线程在这段时间到期时还没有结束的话，join()方法总能返回。

对join()方法的调用可以被中断，做法是在调用线程上调用interrupt()方法，这时需要用到try-catch子句。

下面这个例子演示了所有这些操作：

package concurrency;
    
    class Sleeper extends Thread {
    	private int duration;
    
    	public Sleeper(String name, int sleepTime) {
    		super(name);
    		duration = sleepTime;
    		start();
    	}
    
    	public void run() {
    		try {
    			sleep(duration);
    		} catch (InterruptedException e) {
    			System.out.println(getName() + " was interrupted.isInterrupted(): " + isInterrupted());
    		}
    		System.out.println(getName() + "已被唤醒");
    	}
    }
    
    class Joiner extends Thread {
    	private Sleeper sleeper;
    
    	public Joiner(String name, Sleeper sleeper) {
    		super(name);
    		this.sleeper = sleeper;
    		start();
    	}
    
    	public void run() {
    		try {
    			sleeper.join();
    		} catch (InterruptedException e) {
    			System.out.println("打断");
    		}
    		System.out.println(getName() + "连接完成");
    	}
    }
    
    public class Joining {
    	public static void main(String[] args) {
    		Sleeper sleepy = new Sleeper("sleepy", 1500), grumpy = new Sleeper("grumpy", 1500);
    		Joiner dopey = new Joiner("Dopey", sleepy), doc = new Joiner("Doc", sleepy);
    		grumpy.interrupt();
    	}
    }

Sleeper是一个Thread类型，它要休眠一段时间，这段时间是通过构造器传进来的参数所指定的。在run()中，sleep()方法有可能在指定的时间期满时返回，但也可能被中断。在catch子句中，将根据isInterrupted()的返回值报告这个中断。当另一个线程在该线程上调用interrupt()时，将给该线程设定一个标志，表明该线程已经被中断。然而，异常被捕获时将清理这个标志，所以在catch子句中，在异常被捕获的时候这个标志总是为假。除异常之外，这个标志还可用于其他情况，比如线程可能会检查其中断状态。

Joiner线程将通过在Sleeper对象上调用join()方法来等待Sleeper醒来。在main()里面，每个Sleeper都有一个Joiner，这可以在输出中发现，如果Sleeper被中断或者是正常结束，Joiner将和Sleeper一同结束。

注意，java SE5的java.util.concurrent类库包含诸如CyclicBarrier（本章稍后会展示）这样的工具，它们可能比最初的线程类库中的join()更加合适。

### 十二、创建有响应的用户界面 ###

如前所述，使用线程的动机之一就是建立有响应的用户界面。尽管我们要在下一章才接触到图形用户界面，但是下面还是给出了一个基于控制台用户界面的简单教学示例。下面的例子有两个版本：一个关注于运算，所以不能读取控制台输入；另一个把运算放在任务里单独运行，此时就可以在进行运算的同时监听控制台输入。

package concurrency;
    
    import java.io.IOException;
    
    class UnresponsiveUI {
    	private volatile double d = 1;
    
    	public UnresponsiveUI() throws IOException {
    		while (d > 0)
    			d = d + (Math.PI + Math.E) / d;
    		System.in.read();
    	}
    }
    
    public class ResponsiveUI extends Thread {
    	private static volatile double d = 1;
    
    	public ResponsiveUI() {
    		setDaemon(true);
    		start();
    	}
    
    	public void run() {
    		while (true)
    			d = d + (Math.PI + Math.E) / d;
    	}
    
    	public static void main(String[] args) throws IOException {
    //		new UnresponsiveUI(); //必须终止此进程
    		new ResponsiveUI();
    		System.in.read();
    		System.out.println(d);
    	}
    }

UnresponsiveUI在一个无限的while循环里执行运算，显然程序不可能到达读取控制台输入的那一行（编译器被欺骗了，相信了While的条件使得程序能到达读取控制台输入的那一行）。如果把建立UnresponsiveUI的那一行注释解除掉再运行程序，那么要终止它的话，就只能杀死这个进程。

要想让程序有响应，就得把计算程序放在run()方法中，这样它就能让出处理器给别的程序。当你按下“回车”键的时候，可以看到计算确实在作为后台程序运行，同时还在等待用户输入。

### 十三、线程组 ###

线程组持有一个线程集合。线程组的价值可以引用Joshua Bloch的话来总结，他在Sun时是软件架构师，订正并极大的改善了JDK1.2中java集合类库：

“最好把线程组看成是一次不成功的尝试，你只要忽略它就好了。”

如果你花费了大量的时间和精力试图发现线程组的价值，那么你可能会惊异，为什么没有来自Sun的关于这个主题的官方声明，多年以来，相同的问题对于java发生的其他变化也询问过无数遍。诺贝尔经济学奖得主Joseph Stiglitz的生活哲学可以用来解释这个问题，它被称为承诺升级理论（The Theory of Escalating Commitment）：

“继续错误的代价由别人来承担，而承诺错误的代价由自己承担。”

### 十四、捕获异常 ###

由于线程的本质特性，使得你不能捕获从线程中逃逸的异常。一旦异常逃出任务的run()方法，它就会向外传播到控制台，除非你采取特殊的步骤捕获这种错误的异常。在java SE5之前，你可以使用线程组来捕获这些异常，但是有了java SE5，就可以用Executor来解决这个问题，因此你就不再需要了解有关线程组的任何知识了。

下面的任务总是会抛出一个异常，该异常会传播到其run()方法的外部，并且main()展示了当你运行它时所发生的事情：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ExceptionThread implements Runnable {
    
    	@Override
    	public void run() {
    		throw new RuntimeException();
    	}
    
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newCachedThreadPool();
    		exec.execute(new ExceptionThread());
    	}
    }

输出如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

将main的主体放到try-catch语句块中是没有作用的：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NaiveExceptionHandling {
    	public static void main(String[] args) {
    		try {
    			ExecutorService exec = Executors.newCachedThreadPool();
    			exec.execute(new ExceptionThread());
    		} catch (RuntimeException e) {
    			System.out.println("异常已被处理!");
    		}
    	}
    }

这将产生与前面相同的结果：未捕获的异常。

为了解决这个问题，我们要修改Executor产生线程的方式。Thread.UncaughtExceptionHandler是java SE5中的新接口，它允许你在每个Thread对象上都附着一个异常处理器。Thread.UncaughtExceptionHandler.uncaughtException()会在线程因未捕获的异常而临近死亡时被调用。为了使用它，我们创建了一个新的类型ThreadFactory，它将每个新创建的Thread对象上附着一个Thread.UncaughtExcepitonHandler。我们将这个工厂传递给Executors创建新的ExecutorService的方法：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadFactory;
    
    class ExceptionThread2 implements Runnable {
    	@Override
    	public void run() {
    		Thread t = Thread.currentThread();
    		System.out.println("run() by " + t);
    		System.out.println("eh = " + t.getUncaughtExceptionHandler());
    		throw new RuntimeException();
    	}
    }
    
    class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    
    	@Override
    	public void uncaughtException(Thread t, Throwable e) {
    		System.out.println("捕捉 " + e);
    	}
    
    }
    
    class HandlerThreadFactory implements ThreadFactory {
    
    	@Override
    	public Thread newThread(Runnable r) {
    		System.out.println(this + "creating  new Thread");
    		Thread t = new Thread(r);
    		System.out.println("created " + t);
    		t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    		System.out.println("eh = " + t.getUncaughtExceptionHandler());
    		return t;
    	}
    
    }
    
    public class CaptureUncaughtException {
    	public static void main(String[] args) {
    		ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
    		exec.execute(new ExceptionThread2());
    	}
    }

在程序中添加了额外的跟踪机制，用来验证工厂创建的线程会传递给UncaughtExceptionHandler 。你现在可以看到，未捕获的异常是通过UncaughtException来捕获的。

上面的示例使得你可以按照具体情况逐个地设置处理器。如果你知道将要在代码中处处使用相同的异常处理器，那么更简单的方式是在Thread类中设置一个静态域，并将这个处理器设置为默认的未捕获异常处理器：

package concurrency;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SettingDefaultHandler {
    	public static void main(String[] args) {
    		Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    		ExecutorService exec = Executors.newCachedThreadPool();
    		exec.execute(new ExceptionThread());
    	}
    }

这个处理器只有在不存在线程专有的未捕获异常处理器的情况下才会被调用。系统会检查线程专有版本，如果没有发现，则检查线程组是否有其专有的uncaughtException()方法，如果也没有，在调用DefaultUncaughtExceptionHandler。

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: /images/20230312/06b6668d14534692abaebd46af7952c3.png