Java多线程——线程管理

前面两篇博客介绍了多线的基本概念，以及线程同步与协作。本文将继续探讨线程的管理与多线程的性能优化，具体内容包括：线程池、Callable接口，以及如何优雅第终止线程或者如何管理可能需要立即终止的线程。

一、线程池
在第一篇博客中已经介绍过“线程”和“任务”的关系，如果“任务”是货车，“线程”则是供货车行驶的车道。在之前的介绍中，都是一辆“货车”对应一条“车道”。“车道”也是一个对象，他也需要占用一定的资源，创建和销毁线程会占用时间以及系统资源。那么有没有复用“车道”的机制呢？有！它就是”线程池“。
线程池的意义在于：
1、减少在创建和销毁线程上所花的时间以及系统资源的开销，提升任务执行性能。
2、控制进程中线程数量的峰值，避免系统开销过大。
通过线程池，可创建一定数量的线程，并由线程池管理。在需要执行任务时，直接使用其中的线程。任务执行完成后，线程保留，并可用于执行下一个任务。如果任务比线程多，则等待线程空闲。

线程池的使用

private static void createThreadPool()
    {
        ExecutorService service = Executors.newFixedThreadPool(2); // 创建包含指定线程数的线程池
        service1.execute(new Runnable() {
            public void run() {
                // do something
            }
        }); // 执行任务
        service.shutdown();  // 关闭线程池
    }

以上创建了一个包含两条线程的线程池，并且使用线程池执行了一个匿名任务，完成关闭线程池。
线程池使用中的几个关键对象关系：

• Executor：是一个执行接口，只包含 void execute(Runnable command)声明。
• ExecutorService：继承Executor接口，提供管理、终止线程的方法，可以跟踪任务执行状况生成 Future。
• Executors：定义 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。用于创建ExecutorService 或ThreadFactory 等。
  可以看出Executors充当的是一个工具角色，主要作用是创建和处理。

下面详细介绍一下线程池的几个常用方法。
1、创建线程池
创建线程池常用如下两个方法：
ExecutorService service1 = Executors.newFixedThreadPool(2);
ExecutorService service2 = Executors.newCachedThreadPool();
Executors.newFixedThreadPool(2) 初始化指定数量的线程，如果线程意外终止，将重建并替换。
Executors.newCachedThreadPool() 根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。若创建的线程空闲60秒以上则将其销毁并移除。

2、关闭线程池
关闭线程池有两种方法
void shutdown()：
启动一次顺序关闭，正在执行的任务会继续执行，但不接受新任务。所有任务完成后，关闭线程池。
List < Runnable > shutdownNow():
试图停止所有执行中的任务，暂停等待中的任务，并返回等待执行的任务列表，立即关闭线程池。
注意：无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。无法响应中断的任务可能无法终止。

线程复用

public class TestExecutorPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new PrintStr("A"));// AB同时执行
        service.execute(new PrintStr("B"));
        service.execute(new PrintStr("C"));// 在AB完成后执行
        service.shutdown();
    }
}

class PrintStr implements Runnable {
    String str;
    public PrintStr(String str) {
        this.str = str;
    }

    public void run() {
        try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println(str +" : "+Thread.currentThread().getName());
    }
}

执行结果：
A : pool-1-thread-1
B : pool-1-thread-2
C : pool-1-thread-1
我创建了一个包含2条线程的线程池，但执行3个任务，从结果可以看出第三个任务使用的线程名称与第一个任务相同，即任务3与任务1使用同一条线程。还可以看出，任务3实在前两个任务完成后再执行的。

再看看缓冲池的情况

public class TestExecutorPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new PrintStr("A"));
        service.execute(new PrintStr("B"));
        service.execute(new PrintStr("C"));
        // 等待以上任务执行完毕 
        try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}

        service.execute(new PrintStr("D"));// 会复用空闲的Thread
        service.execute(new PrintStr("E"));// 会复用空闲的Thread
        service.shutdown();
    }
}

class PrintStr implements Runnable {
    String str;
    public PrintStr(String str) {
        this.str = str;
    }

    public void run() {
        try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println(str +" : "+Thread.currentThread().getName());
    }
}

执行结果
A : pool-1-thread-1
B : pool-1-thread-2
C : pool-1-thread-3
E : pool-1-thread-3
D : pool-1-thread-2
分析结果，newCachedThreadPool（）创建的线程池，线程数量根据需要创建。即如果池中没有空闲线程，则创建一条新线程（3个任务创建了3个线程）。若有有空闲线程，则复用（任务D、E复用了线程2和2）。

二、Callable接口
Callable接口与Runnable接口相似，都用于定义线程的可执行任务。Callable在JDK 1.5引入，与Runnable相比，有三个优势：

• 可以在任务中抛出异常
• 可以终止任务

• 可以获取任务的返回值

  看看接口定义的源码：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

对比Runnable接口：

public interface Runnable {
    public void run();
}

接口很简单，Callable的call方法相比Runnable的run方法，多了返回值和抛出异常。
那么问题来了：新旧两种定义线程任务的方式，怎么前后兼容呢？
JDK 1.5为此提供了一个类：FutureTask

public class FutureTask<V> implements RunnableFuture<V> {
    // 封装实现Callable接口的任务
    public FutureTask(Callable<V> callable) { //...}

    // 封装实现Runnable接口的任务，result是返回值，在任务完成后赋值（futureTask.get()会返回这个值）。
    public FutureTask(Runnable runnable, V result) {//...}
    //...其他属性及方法省略...
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

这是典型的适配器模式，只要将Callable或Runnable封装成FutureTask，即可在两种场景使用。

Future 管理异步任务的执行结果，功能介绍如下：

public interface Future<V> {

    /**
     * 试图退出任务（取消执行）
     * @param mayInterruptIfRunning 是否需要等待任务执行完成
     * @return 退出成功返回ture
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * 判断任务是否被退出（中途终止）。
     * @return 如果在任务结束前退出了，返回true.
     */
    boolean isCancelled();

    /**
     * 判断任务是否执行完毕
     * @return 执行完毕返回ture,否则返回false.
     */
    boolean isDone();

    /**
     * 等待任务完成后，返回结果。
     * @return 计算结果
     * @throws CancellationException 如果任务中途退出
     * @throws ExecutionException 如果任务执行过程抛出异常
     * @throws InterruptedException 如果任务线程被打断
     */
    V get() throws InterruptedException, ExecutionException;

    // 等待特定时间后，获取执行结果。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

使用Callable接口

public class TestCallable {
    public static void main(String[] args) {
        FutureTask<String> task = new FutureTask<String>(new MyCallableTask());
        new Thread(task).start();
        System.out.println(getValueFormFuture(task));
        System.out.println("这句将在task.get()阻塞结束后执行！");
    }

    private static String getValueFormFuture(FutureTask<String> task){
        String str = "defaultValue";
        try {
            str = task.get();// task.get()会阻塞当前线程，等待子线程结束。
        } catch (Exception e) {
            System.out.println("任务已经被取消！");
        }
        return str;
    }
}

class MyCallableTask implements Callable<String> {
    public String call() throws Exception {
        int num = 0;
        for (int i = 0; i < 3; i++) {
            num++;
            System.out.println("num="+num);
        }
        return String.valueOf(num);
    }
}
}

执行结果：
num=1
num=2
num=3
执行结果：3
这句将在task.get()阻塞结束后执行！

再对比Runnable接口使用，代码做细微调整:

public static void main(String[] args) {
        String defaultValue = "defaultValue";// 如果不需要返回值，可以传入null。
        FutureTask<String> task = new FutureTask<String>(new MyRunnableTask (),defaultValue);
        new Thread(task).start();
        System.out.println(getValueFormFuture(task));
        System.out.println("这句将在task.get()阻塞结束后执行！");
    }

class MyRunnableTask implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("num="+i);
        }
    }
}

执行结果：
num=0
num=1
num=2
执行结果：defaultValue
这句将在task.get()阻塞结束后执行！

可以看到，使用Runnable构造FutureTask时，future.get()直接得到defaultValue。

三、中断任务线程
测试描述：任务线程，每0.1秒打印一个数，打印3次。主线程在任务启动0.25秒后，中断任务。

1、中断Callable任务
来改造一下main方法及MyCallableTask代码：

public static void main(String[] args) {
        FutureTask<String> task = new FutureTask<String>(new MyCallableTask());
        new Thread(task).start();
        try {Thread.sleep(250);} catch (InterruptedException e) {e.printStackTrace();}
        task.cancel(true); // 中断线程，ture表示不必等待执行完成（会打断线程）。
        System.out.println(getValueFormFuture(task));
        System.out.println("这句将在task.get()阻塞结束后执行！");
}

class MyCallableTask implements Callable<String> {
    public String call() throws Exception {
        int num = 0;
        for (int i = 0; i < 3; i++) {
            Thread.sleep(100);
            num++;
            System.out.println("num="+num);
        }
        return String.valueOf(num);
    }
}

执行结果：
num=1
num=2
任务已经被取消！
defaultValue
这句将在task.get()阻塞结束后执行！

调用task.cancel(true)后，任务中止成功。但如果采用task.cancel(false)将得到如下结果：
num=1
num=2
任务已经被取消！
defaultValue
这句将在task.get()阻塞结束后执行！
num=3
cancle()后，退出了get方法的阻塞，但任务线程继续执行。

2、中断Runnable任务

public static void main(String[] args) {
        String result="defaultValue";
        FutureTask<String> task = new FutureTask<String>(new MyRunnable(),result);
        new Thread(task).start();
        try {Thread.sleep(250);} catch (InterruptedException e) {e.printStackTrace();}
        task.cancel(true);
        System.out.println(getValueFormFuture(task));
        System.out.println("这句将在task.get()阻塞结束后执行！");
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("任务被打断！");
            }
            System.out.println("num="+i);
        }
    }
}

执行结果：
num=0
num=1
任务被打断！
num=2
任务已经被取消！
defaultValue
这句将在task.get()阻塞结束后执行！
num=3

cancle()后，退出了get方法的阻塞，但任务继续执行。那么对Runnable接口采用task.cancel(false)将会得到什么结果呢：
num=0
num=1
任务已经被取消！
defaultValue
这句将在task.get()阻塞结束后执行！
num=2
num=3

与使用ture参数相似，任务线程依然继续执行，只是打印顺序不一样。那么造成这种差异的原因是什么呢？
这就涉及到FutureTask的get()方法退出阻塞的原理了。任务设置打断状态后，需要从睡眠中唤醒后才能检测并设置相关状态参数，具体不做探讨。
到这里，我们可以得出结论：

• 实现Callable接口的任务线程，可以通过future.cancle()立即终止任务。
• 实现Runnable接口的任务线程，不能通过future.cancle()立即终止任务。

特殊的场景：Runnable任务是循环执行的，这种任务是可以做到立即中断的，方法如下：
中断任务使用task.cancel(true)，再在任务打断时return。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("任务被打断！");
                return; // 检测到打断后，结束任务！
            }
            System.out.println("num="+i);
        }
    }
}

执行结果：
num=0
num=1
任务被打断！
任务已经被取消！
defaultValue
这句将在task.get()阻塞结束后执行！

任务未执行完毕，中断成功！

3、线程池管理线程任务
通过ExecutorService，可以使用4个方法执行线程任务。
其中3个执行Runnable任务：
void execute(Runnable command);
< T > Future< T > submit(Runnable task, T result);
Future< ? > submit(Runnable task);

1个执行Callable任务：
< T > Future< T > submit(Callable< T > task); 执行Callable任务

只有通过submit方法执行的线程任务，才能获取到Future，才能通过Future管理线程。

public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<String> future = service.submit(new MyCallableTask()); // 使用submit()执行Callable任务
        String str = getValueFormFuture(future);
        System.out.println("执行结果："+str);
}

执行结果：
num=1
num=2
num=3
执行结果：3

注：通过线程池submit执行Runnable 或Callable任务得到的Future，与直接通过Thread执行FutureTask的到的Future一样，按照前面的测试，结果一致。

4、利用后台线程管理任务
Thread类提供了一个setDaemon方法，可以将线程设置成后台（守护）线程，当宿主线程任务完成后，后台线程自动终止。
看看方法定义：

    /**
     * Marks this thread as a daemon thread.
     * A daemon thread only runs as long as there are non-daemon threads running.
     * When the last non-daemon thread ends, the runtime will exit. This is not
     * normally relevant to applications with a UI.
     * @throws IllegalThreadStateException - if this thread has already started.
     */
    public final void setDaemon(boolean isDaemon) {
        checkNotStarted();

        if (nativePeer == 0) {
            daemon = isDaemon;
        }
    }

后台线程定义很明确，台线程的作用是为主线程提供服务，主线程结束后，服务也就终止。下面看个Demo。定义一个主线程，他的任务有两个：
1.启动后台线程，每0.1s打印一个字符，共打印5个。
2.每0.1s打印一个字符，共打印2个。

public class TestDemonThread {
    public static void main(String[] args) {
        MainThread thread = new MainThread();
        thread.start();
    }
}

class MainThread extends Thread{
    @Override
    public void run() {
        Thread demon = new Thread(){
            public void run() {
                for(int i=1;i<=5;i++){printNum(i);}
            };
        };
        demon.setDaemon(true);
        demon.start();

        for(int i=1;i<=2;i++){printNum(i);}
    }

    private void printNum(int num){
        try {Thread.sleep(100);} catch (InterruptedException e) {
            System.out.println("后台线程被打断");
        }
        System.out.print(num);
    }
}

执行结果：
1122
程序只打印了4个字符，主线程和后台线程分别打印两个。验证了后台线程与主线程的关闭时间关系。
利用这种特性，也可以实现实时地终止线程。比如：主线程在启动后台线程后，开始睡眠，当需要终止后台线程时，唤醒主线程，因主线程没有其他任务，会直接完成任务退出，从而使后台线程结束。