Java并发编程（二）多线程编程

在上一节，我们介绍了进程与线程的概念，接下来介绍如何使用多线程（暂不介绍多进程）。

2. Thread对象

每个线程都对应一个Thread实例，存在两种策略使用Thread类来创建并发程序。

• 直接进行线程的创建和管理，也就是当需要开启一个异步任务时，实例化一个Thread对象。
• 抽象线程管理，将执行任务交给执行器。

本节介绍如何使用Thread类。

2.1 定义和执行新的线程

在创建新线程的时候，我们需要指定该线程运行的代码。我们有两种途径：

• 提供一个Runnable对象。Runnable接口值定义了一个方法run(), 该方法会被线程执行。Runnable对象作为参数传递给Thread的构造函数，如下所示，

public class HelloRunnable implements Runnable {    public void run() {        System.out.println("Hello from a thread!");    }    public static void main(String args[]) {        (new Thread(new HelloRunnable())).start();    }}

• 继承Thread。Thread类实现了run()方法，虽然该方法并没有做任何事情。一个程序可以继承Thread类，提供run方法的实现，如下所示，

public class HelloThread extends Thread {    public void run() {        System.out.println("Hello from a thread!");    }    public static void main(String args[]) {        (new HelloThread()).start();    }}

注意到，两个线程都使用了Thread.start()来执行线程。

你应该使用哪一种风格？第一种方式，使用了Runnable对象，是更加通用的，因为Runnable可以继承一个不是Thread类的对象。第二种方式在简单的程序中使用更加方便，但是其限制了执行的任务必须是Thread的子类。该教程侧重与第一种风格，其将Runnable与Thread分离。该方法不仅更加灵活，也适用于高级别的线程管理APIs（在以后介绍）。

Thread类定义了一些线程管理的方法。这些包括一些提供关于执行该方法的线程的信息，或者影响该线程的状态的静态（static）方法。其他方法为非静态方法，在另一个线程中调用，用来维护Thread对象。

2.2 使用Sleep暂停线程

Thread.sleep导致当前线程暂停一个指定的时间。这是一个有效的方式，来使得其他进程或线程可以使用处理器。sleep方法可以用于调整代码运行的节奏，如接下来的代码，或者等待其他线程的完成，如本节最后的SimpleThreads例子。

Java提供了两个重载的sleep方法，一个指定休眠的毫秒记时，一个是纳秒记时。但是，该两个方法都不能保证休眠时间的准确性，这是因为他们被底层的系统控制的。另外，休眠的时间段可以被中断终止。在任何情况下，我们不能假设sleep可以暂停一个精确的时间。

SleepMessages示例了如何使用sleep以4s为间隔输出一个消息。

public class SleepMessages {    public static void main(String args[])        throws InterruptedException {        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            Thread.sleep(4000);            //Print a message            System.out.println(importantInfo[i]);        }    }}

注意到，main方法抛出了InterruptedException 异常。当其他线程中断一个处于休眠状态下的线程时，会抛出该异常。由于该程序并没有定义其他可以导致中断的线程，所以没有处理该异常（catch），只是抛出（throw）。

2.3 中断

中断是一个信号，说明该线程应该停止当前的任务，去做其他的任务。由开发者决定一个线程如何响应中断，但是终止该线程的常见的。

一个线程可以调用interrupt()方法来中断另一个线程。为了中断机制正常运行，中断的线程必须支持自己的中断操作。

2.3.1 支持中断操作

一个线程如何支持中断操作呢？这取决于该线程当前做什么。如果该线程频繁调用抛出InterruptedException异常的方法，当它捕获到异常后，run()方法中返回就可以了。举个例子，假设SleepMessages例子中的消息循环在一个Runnable对象的run()方法中，我们可以这样来支持中断操作，

for (int i = 0; i < importantInfo.length; i++) {    // Pause for 4 seconds    try {        Thread.sleep(4000);    } catch (InterruptedException e) {        // We've been interrupted: no more messages.        return;    }    // Print a message    System.out.println(importantInfo[i]);}

很多抛出InterruptedException 异常的方法，例如sleep，被设计成当收到中断信号后，取消当前操作。

如果一个线程长时间执行一个没有抛出InterruptedException 的方法呢？那么他必须周期地执行Thread.interrupted，来判断其是否被中断，
例如，

for (int i = 0; i < inputs.length; i++) {    heavyCrunch(inputs[i]);    if (Thread.interrupted()) {        // We've been interrupted: no more crunching.        return;    }}

在该例子中，代码仅仅测试了中断和退出线程。在更复杂的程序中，抛出一个异常会更加有意义，

if (Thread.interrupted()) {    throw new InterruptedException();}

这允许在catch语句中加入中断处理代码。

2.3.2 中断标志位

中断机制通过一个成为中断状态（interrupt status）的标志位来实现。调用Thread.interrupt将会设置该标志。当一个线程调用静态方法Thread.interrupted方法来检查中断时，中断状态被清除。非静态方法isInterrupted，用来检查另一个线程的中断状态，并不会改变线程状态标志。

按照规定，任何通过抛出InterruptedException异常来退出的线程都会清除中断状态。当另一个线程调用interrupt后，该线程的中断状态会被重新设置。

2.4 联合（Joins）

join方法允许一个线程等待另一个线程执行结束。如果t是一个正在执行的线程对象，

t.join();

会导致当前线程暂停执行直到线程t执行结束。joins方法的重载方法允许开发者指定等待的周期。然而，由于join和sleep依赖于系统的时间，所以你不能假设join会精确等待你指定的时间。

和sleep一样，join会抛出一个InterruptedException异常退出线程，来相应中断操作。

2.5 SimpleThreads例子

下面的例子将一些概念包括在一起。SimpleThreads包括两个线程。一个是主线程，每个java程序都会包括一个主线程。主线程从Runnable对象创建了MessageLoop线程，并且等待该线程执行完毕。如果MessageLoop线程执行时间过长，主线程中断该线程。

MessageLoop线程输出一系列消息，如果中断发生在它输出所有消息之前，MessageLoop会输出一个消息并退出。

public class SimpleThreads {    // Display a message, preceded by    // the name of the current thread    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"            };            try {                for (int i = 0;                     i < importantInfo.length;                     i++) {                    // Pause for 4 seconds                    Thread.sleep(4000);                    // Print a message                    threadMessage(importantInfo[i]);                }            } catch (InterruptedException e) {                threadMessage("I wasn't done!");            }        }    }    public static void main(String args[])        throws InterruptedException {        // Delay, in milliseconds before        // we interrupt MessageLoop        // thread (default one hour).        long patience = 1000 * 60 * 60;        // If command line argument        // present, gives patience        // in seconds.        if (args.length > 0) {            try {                patience = Long.parseLong(args[0]) * 1000;            } catch (NumberFormatException e) {                System.err.println("Argument must be an integer.");                System.exit(1);            }        }        threadMessage("Starting MessageLoop thread");        long startTime = System.currentTimeMillis();        Thread t = new Thread(new MessageLoop());        t.start();        threadMessage("Waiting for MessageLoop thread to finish");        // loop until MessageLoop        // thread exits        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!");    }}

文章翻译自Java Tutorials, Concurrency，翻译难免会有纰漏，欢迎读者讨论指正。