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

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，翻译难免会有纰漏，欢迎读者讨论指正。

秒客网

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