Java 并发入门

一、并发

进程：每个进程都拥有自己的一套变量

线程：线程之间共享数据

1.线程

Java中为多线程任务提供了很多的类。包括最基础的Thread类、Runnable等接口，用于线程同步的锁、阻塞队列、同步器，使用线程池的执行器、执行框架，还有可以在多线程中使用的线程安全集合等。

(1)使用多线程给其他任务提供机会

创建线程：

• 将任务代码移到实现了Runnable接口的类的run方法中，这个接口非常简单，只有一个方法：

public interface Runnable{
    void run();
}

• 由Runnable创建一个Thread对象

Thread t = new Thread(r);

• 启动线程：

t.start();

注意：不要调用Thread或Runnable对象中的run方法，只会执行同一个线程中的任务，不会启动新的线程，应该使用Thread的start方法。

---

二、中断线程

没有终止线程的方法，只能通过interrupt方法来请求中断。

Thread或Runnable对象的run()方法包装了新线程中执行的代码，在run()方法中遇到下面的情况，线程会终止。

• 正常终止。执行完最后一条语句，也包括遇到return返回
• 异常终止。出现未捕获的异常

强制结束：

• 调用Thread对象的stop()方法。抛出一个ThreadDeath异常，停止线程执行（这个异常如果被捕获一定要重新抛出）。这个方法已经不推荐使用，原因是线程可能停止在一个不安全的状态（例如转账操作，从一个账号减了钱，还没加到另一个账号，线程被强制结束了），应该使用请求中断的方式。
• 请求中断方式。要结束一个线程，就设置该线程的中断变量(调用Thread对象的interrupt()方法)（表明着有人想要中断这个线程），线程中的代码自己要负责查询中断变量（Thread类静态方法interrupted()或Thread对象的isInterrupted()方法），如果发现中断变量被设置了就自觉点不要再执行了，恢复到安全的状态后自行退出。请求中断不是强制的，如果线程中的代码不查询中断变量，或者发现中断变量已经被设置了但是不理会继续厚着脸皮执行，这个线程还是会一直运行不会被停止。

//栗子

public class InterruptTest {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread t = new MyThread("MyThread");  
        t.start();  
        Thread.sleep(100);// 睡眠100毫秒  
        t.interrupt();// 中断t线程  
    }  
}  
class MyThread extends Thread {  
    int i = 0;  
    public MyThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {// 当前线程没有被中断，则执行  
            System.out.println(getName() + getId() + "执行了" + ++i + "次");  
        }  
    }  
}  

void interrupt()方法和InterruptedException特别说明

• 如果调用interrupt方法时，若线程正被某些可中断的方法阻塞着（sleep，wait或可中断IO调用等），那么现在肯定是无法检测中断状态的，系统会清理中断状态，抛出InterruptedException异常，阻塞的方法调用会立即被这个异常中断。
• 如果调用interrupt方法将中断状态设置为了true，不久就调用了一个可中断的方法（sleep,wait,可中断IO调用等），这个调用不会成功，并且同样会清除中断状态标志，使中断标志为false，抛出InterruptedException异常。可见，如果会循环调用sleep()这类可中断的方法，就不需要再手动检测中断状态了。
• interrupt向线程发送中断请求，线程的中断状态将被设置为true，如果目前线程被阻塞，那么InterruptedException异常将被抛出，中断状态会被设为false。

Thread的static boolean interrupted():

• 测试当前线程是否被中断，这一调用会产生一个副作用，它将当前线程的中断状态重置为false

Thread的boolean isInterrupted():

• 测试线程是否被终止，这一调用不会改变线程的中断状态。

可见如果不设置中断，InterruptedException肯定不会出现，而只要抛出InterruptedException，设置的中断状态肯定已经被清理了，这种情况只有InterruptedException这个异常是我们知道有中断请求的唯一标识了，因此我们要向外层通知有中断发生，千万不要再把这个异常压制住，否则怎么调用interrupt()方法请求中断都不会有作用，线程中外层的代码压根不知道有中断这回事，照常运行。将这个中断请求通知给外层有两种方式：

• catch到InterruptedException时，调用Thread.currentThread().interrupt()，重新把中断状态设置上，让外层可以检测到。
• 最好的方法是，不要再catch InterruptedException异常啦，只要有这个异常就往外层抛吧。一直抛到最外层，在Thread对象或Runnable对象的run()方法中处理这个异常（处理操作：恢复到安全的状态然后自觉退出）。

public class Erupt {
    static class MyInterruptableExceptionTask implements Runnable
    {
        private int begin=0;
        public MyInterruptableExceptionTask(int s){begin=s;}
        @Override
        public void run() {
            try {
                int end=begin+10;
                for(int i=begin; i<end; i++){
                    System.out.println("sub: "+i);
                    Thread.sleep(1000);    //如果设置中断时正在sleep，或设置完中断后一个循环里遇到sleep，都会抛出InterruptedException异常，不需要再手动检测中断状态了
                }
            } catch (InterruptedException e) {
                System.out.println("the call Thread.sleep(n) is interrupted by InterruptedExcetpion");
                Thread.currentThread().interrupt();    //产生InterruptedException异常时中断状态被清除，所以要重新设置中断或将中断异常向外抛出供后续代码检测是否发生了中断
            }

            if(Thread.currentThread().isInterrupted())
                System.out.println("sub thread is interrupted");
            else
                System.out.println("sub natural stop");
        }
    }

    public static void main(String[] args) {
        Thread t=new Thread(new MyInterruptableExceptionTask(111));
        t.start();

        for(int i=0; i<10; i++){
            System.out.println("main: "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i==5)
                t.interrupt();
        }
    }


}

---

三、线程状态

线程有6中状态：

• New：用new操作符创建一个新线程时，如 new Thread(r), 该线程还没有开始运行。这意味着它的状态是new，当一个线程处在new状态，程序还没有开始运行线程中的代码。在线程运行之前还有一些基础工作要做。
• Runnable：一旦调用start()方法，线程就处于runnable状态。可以可运行的线程可能正在运行也可能没有运行，这取决于操作系统给线程提供运行的时间(这就是为什么这个状态成为可运行而不是运行)，事实上，运行中的线程被中断，目的是为了让他们线程获得运行机会。线程调度的细节依赖于操作系统提供的服务。抢占式调度系统给每一个可运行线程一个时间片来执行任务，当时间片用完，操作系统剥夺该线程的运行权，并给另一个线程可运行机会。当选择下一个线程时，操作系统考虑线程的优先级。
• Bolocked：阻塞，当一个线程试图获取一个内部的对象锁(而不是java.util.concurrent库里的锁), 而该锁被其他线程持有，则该线程进入阻塞状态。当其他线程释放该锁，并且线程调度器允许本线程持有它的时候，该线程将变成非阻塞状态。
• Waiting：等待，当线程通知另一个线程通知调度器一个条件时，它自己进入等待状态。在调用Object.wait方法或Thread.join方法，或者是等待java.util.concurrent库中的Lock或Condition时，就会出现这种情况。实际上，被阻塞状态与被等待状态是有很大不同的。
• Timed waiting：计时等待，有几个方法有一个超时参数。调用它们导致线程进入计时等待(timed waiting)状态。这一状态将一直保持到超时期满或者接收到适当的通知。带有超时参数的方法有Thread.sleep和Object.wait, Thrad.join, Lock.tryLock以及Condition.await的计时版。
• Terminated：因为run方法正常退出而自然死亡；-因为一个没有捕获的异常终止了run方法二意外死亡

image

• 抛异常：如果试图的操作无法立即执行，抛一个异常。
• 特定值：如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。
• 阻塞：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。
• 超时：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是true / false)。

BlockingQueue 是个接口，你需要使用它的实现之一来使用BlockingQueue，Java.util.concurrent包下具有以下 BlockingQueue 接口的实现类：

• ArrayBlockingQueue：ArrayBlockingQueue 是一个有界的阻塞队列，其内部实现是将对象放到一个数组里。有界也就意味着，它不能够存储无限多数量的元素。它有一个同一时间能够存储元素数量的上限。你可以在对其初始化的时候设定这个上限，但之后就无法对这个上限进行修改了(译者注：因为它是基于数组实现的，也就具有数组的特性：一旦初始化，大小就无法修改)。
• DelayQueue：DelayQueue 对元素进行持有直到一个特定的延迟到期。注入其中的元素必须实现 java.util.concurrent.Delayed 接口。
• LinkedBlockingQueue：LinkedBlockingQueue 内部以一个链式结构(链接节点)对其元素进行存储。如果需要的话，这一链式结构可以选择一个上限。如果没有定义上限，将使用 Integer.MAX_VALUE 作为上限。
• PriorityBlockingQueue：PriorityBlockingQueue 是一个无界的并发队列。它使用了和类 java.util.PriorityQueue 一样的排序规则。你无法向这个队列中插入 null 值。所有插入到 PriorityBlockingQueue 的元素必须实现 java.lang.Comparable 接口。因此该队列中元素的排序就取决于你自己的 Comparable 实现。
• SynchronousQueue：SynchronousQueue 是一个特殊的队列，它的内部同时只能够容纳单个元素。如果该队列已有一元素的话，试图向队列中插入一个新元素的线程将会阻塞，直到另一个线程将该元素从队列中抽走。同样，如果该队列为空，试图向队列中抽取一个元素的线程将会阻塞，直到另一个线程向队列中插入了一条新的元素。据此，把这个类称作一个队列显然是夸大其词了。它更多像是一个汇合点。

demo：

package blocking_queue;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author Sean
 * @version 1.0
 * @date 创建时间：2017/7/15 14:29
 * @parameter
 * @return
 */
public class BlockingQueueTest {
    public static class Producer implements Runnable{

        private final BlockingQueue<Integer> blockingQueue;
        private volatile boolean flag;
        private Random random;


        public Producer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
            flag = false;
            random = new Random();
        }


        @Override
        public void run() {
            while (!flag){
                int info = random.nextInt(100);

                try {
                    blockingQueue.put(info);
                    System.out.println(Thread.currentThread().getName()+" procuce "+info);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void shutDown(){
            flag = true;
        }
    }

    public static class Consumer implements Runnable{
        private final BlockingQueue<Integer> blockingQueue;
        private volatile boolean flag;
        public Consumer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }
        public void run() {
            while(!flag){
                int info;
                try {
                    info = blockingQueue.take();
                    System.out.println(Thread.currentThread().getName()+" consumer "+info);
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        public void shutDown(){
            flag=true;
        }
    }

    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>(10);
        Producer producer=new Producer(blockingQueue);
        Consumer consumer=new Consumer(blockingQueue);
        //创建5个生产者，5个消费者
        for(int i=0;i<10;i++){
            if(i<5){
                new Thread(producer,"producer"+i).start();
            }else{
                new Thread(consumer,"consumer"+(i-5)).start();
            }
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        producer.shutDown();
        consumer.shutDown();

    }
}

java.util.concurrent包提供了以下几种阻塞队列：

• LinkedBlockingQueue是一个基于链表实现的阻塞队列。默认容量没有上限，但也有可以指定最大容量的构造方法。它有的“双端队列版本”为LinkedBlockingDeque。
• ArrayBlockingQueue是一个基于数组实现的阻塞队列，它在构造时需要指定容量。它还有一个构造方法可以指定一个公平性参数，若这个参数为true，那么等待了最长时间的线程会得到优先处理（指定公平性参数会降低性能）。
• PriorityBlockingQueue是一个基于堆实现的带优先级的阻塞队列。元素会按照它们的优先级被移除队列。

package blockingQueue;

import java.util.concurrent.ArrayBlockingQueue;

public class BlockingQueueTest {
    private int size = 20;
    private ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(size);

    public static void main(String[] args)  {
        BlockingQueueTest test = new BlockingQueueTest();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();

        producer.start();
        consumer.start();
    }

    class Consumer extends Thread{
        @Override
        public void run() {
            while(true){
                try {
                    //从阻塞队列中取出一个元素
                    blockingQueue.take();
                    System.out.println("队列剩余" + blockingQueue.size() + "个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Producer extends Thread{
        @Override
        public void run() {
            while (true) {
                try {
                    //向阻塞队列中插入一个元素
                    blockingQueue.put(1);
                    System.out.println("队列剩余空间：" + (size - blockingQueue.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在以上代码中，我们有一个生产者线程不断地向一个阻塞队列中插入元素，同时消费者线程从这个队列中取出元素。若生产者生产的比较快，消费者取的比较慢导致队列满，此时生产者再尝试插入时就会阻塞在put方法中，直到消费者取出一个元素；反过来，若消费者消费的比较快，生产者生产的比较慢导致队列空，此时消费者尝试从中取出时就会阻塞在take方法中，直到生产者插入一个元素。

---

七、Callable与Future

Callable和Future，它俩很有意思的，一个产生结果，一个拿到结果。

我们之前提到了创建线程的两种方式，它们有一个共同的缺点，那就是异步方法run没有返回值，也就是说我们无法直接获取它的执行结果，只能通过共享变量或者线程间通信等方式来获取。好消息是通过使用Callable和Future，我们可以方便的获得线程的执行结果。
Callable接口与Runnable接口类似，区别在于它定义的异步方法call有返回值。Callable接口的定义如下：

public interface Callable<V> {
    V call() throws Exception;
}

类型参数V即为异步方法call的返回值类型。

来看个简单栗子：

public class CallableAndFuture {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };
        FutureTask<Integer> future = new FutureTask<Integer>(callable);
        new Thread(future).start();
        try {
            Thread.sleep(5000);// 可能做一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，那么这个组合的使用有什么好处呢？假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到，岂不美哉！

Future可以对具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成以及获取结果。可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。Future接口的定义如下：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

在Future接口中声明了5个方法，每个方法的作用如下：

• cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false（即如果取消已经完成的任务会返回false）；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

• isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

• isDone方法表示任务是否已经完成，若任务完成，则返回true；

• get()方法用来获取执行结果，这个方法会阻塞，一直等到任务执行完才返回；

• get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

  Future接口的实现类是FutureTask：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，这个接口的定义如下：

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

可以看到RunnableFuture接口扩展了Runnable接口和Future接口。

FutureTask类有如下两个构造器：

public FutureTask(Callable<V> callable) 
public FutureTask(Runnable runnable, V result) 

FutureTask通常与线程池配合使用，通常会创建一个包装了Callable对象的FutureTask实例，并用submit方法将它提交到一个线程池去执行，我们可以通过FutureTask的get方法获取返回结果。

public class CallableAndFuture {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<Integer> future = threadPool.submit(new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        });
        try {
            Thread.sleep(5000);// 可能做一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

---

九、执行器

创建一个新线程涉及和操作系统的交互，因此会产生一定的开销。在有些应用场景下，我们会在程序中创建大量生命周期很短的线程，这时我们应该使用线程池（thread pool)。通常，一个线程池中包含一些准备运行的空闲线程，每次将Runnable对象交给线程池，就会有一个线程执行run方法。当run方法执行完毕时，线程不会进入Terminated
状态，而是在线程池中准备等下一个Runnable到来时提供服务。使用线程池统一管理线程可以减少并发线程的数目，线程数过多往往会在线程上下文切换上以及同步操作上浪费过多时间。

执行器类（java.util.concurrent.Executors)提供了许多静态工厂方法来构建线程池。

1.线程池

在Java中，线程池通常指一个ThreadPoolExecutor对象，ThreadPoolExecutor类继承了AbstractExecutorService类，而AbstractExecutorService抽象类实现了ExecutorService接口，ExecutorService接口又扩展了Executor接口。也就是说，Executor接口是Java中实现线程池的最基本接口。我们在使用线程池时通常不直接调用ThreadPoolExecutor类的构造方法，二回使用Executors类提供给我们的静态工厂方法，这些静态工厂方法内部会调用ThreadPoolExecutor的构造方法，并为我们准备好相应的构造参数。

Executor是类中的以下三个方法会返回一个实现了ExecutorService接口的ThreadPoolExecutor类的对象：

newCachedThreadPool() //返回一个带缓存的线程池，该池在必要的时候创建线程，在线程空闲60s后终止线程
newFixedThreadPool(int threads) //返回一个线程池，线程数目由threads参数指明
newSingleThreadExecutor() //返回只含一个线程的线程池，它在一个单一的线程中依次执行各个任务
newScheduledThreadPool()//包含预定执行而构建的线程池

• 对于newCachedThreadPool方法返回的线程池：对每个任务，若有空闲线程可用，则立即让它执行任务；若没有可用的空闲线程，它就会创建一个新线程并加入线程池中；
• newFixedThreadPool方法返回的线程池里的线程数目由创建时指定，并一直保持不变。若提交给它的任务多于线程池中的空闲线程数目，那么就会把任务放到队列中，当其他任务执行完毕后再来执行它们；
• newSingleThreadExecutor会返回一个大小为1的线程池，由一个线程执行提交的任务。

以下方法可将一个Runnable对象或Callable对象提交给线程池：

Future<T> submit(Callable<T> task)
Future<T> submit(Runnable task, T result)
Future<?> submit(Runnable task)

调用submit方法会返回一个Future对象，可通过这个对象查询该任务的状态。我们可以在这个Future对象上调用isDone、cancle、isCanceled等方法（Future接口会在下面进行介绍）。第一个submit方法提交一个Callable对象到线程池中；第二个方法提交一个Runnable对象，并且Future的get方法在完成的时候返回指定的result对象。

当我们使用完线程池时，就调用shutdown方法，该方法会启动该线程池的关闭例程。被关闭的线程池不能再接受新的任务，当关闭前已存在的任务执行完毕后，线程池死亡。shutdownNow方法可以取消线程池中尚未开始的任务并尝试中断所有线程池中正在运行的线程。

在使用线程池时，我们通常应该按照以下步骤来进行：

• 调用Executors中相关方法构建一个线程池；
• 调用submit方法提交一个Runnable对象或Callable对象到线程池中；
• 若想要取消一个任务，需要保存submit返回的Future对象；
• 当不再提交任何任务时，调用shutdown方法。

package test;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   fixedThreadPool.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
} 

2.预定执行

ScheduledExecutorService接口含有为预定执行（Scheduled Execution）或重复执行的任务专门设计的方法。Executors类的newScheduledThreadPool和newSingleThreadScheduledExecutor方法会返回实现了ScheduledExecutorService接口的对象。可以使用以下方法来预定执行的任务：

ScheduledFuture<V> schedule(Callable<V> task, long time, TimeUnit unit)
ScheduledFuture<?> schedule(Runnable task, long time, TimeUnit unit)
//以上两个方法预定在指定时间过后执行任务
SchedukedFuture<?> scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit) //在指定的延迟（initialDelay）过后，周期性地执行给定任务
ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit) //在指定延迟（initialDelay）过后周期性的执行任务，每两个任务间的间隔为delay指定的时间

package test;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.schedule(new Runnable() {  
   public void run() {  
    System.out.println("delay 3 seconds");  
   }  
  }, 3, TimeUnit.SECONDS);  
 }  
}  

3.控制任务组

对ExecutorService对象调用invokeAny方法可以把一个Callable对象集合提交到相应的线程池中执行，并返回某个已经完成的任务的结果，该方法的定义如下：

T invokeAny(Collection<Callable<T>> tasks)
T invokeAny(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)

该方法可以指定一个超时参数。这个方法的不足在于我们无法知道它返回的结果是哪个任务执行的结果。如果集合中的任意Callable对象的执行结果都能满足我们的需求的话，使用invokeAny方法是很好的。

invokeAll方法也会提交Callable对象集合到相应的线程池中，并返回一个Future对象列表，代表所有任务的解决方案。该方法的定义如下：

List<Future<T>> invokeAll(Collection<Callable<T>> tasks)
List<Future<T>> invokeAll(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)

---