1. 任务执行服务的基本概念？
   答：

   • 任务执行服务大大简化了执行异步任务所需的开发，它引入了一个“执行服务”的概念，将“任务的提交”和“任务的执行”相分离。“执行服务”封装了任务执行的细节，对于任务提交者而言，它可以关注于任务本身，如提交任务、获取结果、取消任务，而不需要关注任务执行的细节，如线程创建、任务调度、线程关闭等。

   • 任务执行服务主要涉及以下接口：

     • Runnable 和 Callable：表示要执行的异步任务。
     • Executor 和 ExecutorService：表示执行服务。
     • Future：表示异步任务的结果。

   • 使用者只需要通过 ExecutorService 提交任务，通过 Future 操作任务和结果即可，不需要关注线程创建和协调的细节。

2. 怎样理解线程池？
   答：

   • 任务执行服务的主要实现机制是线程池，实现类是 ThreadPoolExecutor。线程池主要由两个概念组成：任务队列和工作者线程。
   • 任务队列是一个阻塞队列，保存待执行的任务，工作者线程主体就是一个循环，循环从队列中接收任务并执行。TheadPoolExecutor 有一些重要的参数，理解这些参数对于合理使用线程池非常重要。
   • ThreadPoolExecutor 实现了生产者/消费者模式，工作线程就是消费者，任务提交者就是生产者，线程池自己维护任务队列。当碰到类似生产者/消费者问题时，应该优先考虑直接使用线程池，而非“重新发明轮子”。

3. 怎样理解定时任务？
   答：异步任务中，常见的任务是定时任务。在 Java 中，有两种方式实现定时任务：

   • 使用 java.util 包中的 Timer 和 TimerTask。
   • 使用 Java 并发包中的 ScheduledExecutorService。

4. Timer 的需要特别注意的地方有？
   答：

   • 一个 Timer 对象背后只有一个 Timer 线程。所以，定时任务不能太长，更不能是无限循环。
   • 在执行任何一个任务的 run() 方法时，一旦 run() 抛出异常，Timer 线程就会退出，从而所有定时任务都会被取消。

5. 怎样理解 ScheduledExecutorService？
   答：

   • ScheduledExecutorService 的主要实现类是 ScheduledThreadPoolExecutor，它没有 Timer 的问题：

     • 它的背后是线程池，可以有多个线程执行任务。
     • 任务执行线程会捕获任务执行过程中的所有异常，一个定时任务的异常不会影响其他定时任务。

   • 实际开发中，当有定时任务时建议使用 ScheduledExecutorService。

6. Java 中还有哪些并发相关的内容？
   答：

   • Java 7 引入的 Fork/Join 框架，Java 8 中有并行流的概念，可以让开发者非常方便地对大量数据进行并行操作，背后基于的就是 Fork/Join 框架。
   • CompletionService，在异步任务程序中，一种场景是：主线程提交多个异步任务，然后希望有任务完成就处理结果，并且按任务完成顺序逐个处理。对于这种场景，Java 并发包提供了一个方便的方法，那就是使用 CompletionService。CompletionService 是一个接口，它的实现类是 ExecutorCompletionService，它通过一个额外的结果队列，方便了对于多个异步任务结果的处理（细节可参考微信公众号“老马说编程”第 79 篇文章）。
   • Java 8 引入组合式异步编程 CompletableFuture，它可以方便地将多个有一定依赖关系的异步任务以流水线的方式组合在一起，自然地表达任务之间的依赖关系和执行流程，大大简化代码，提高可读性。

1. Java 中线程安全的容器类的分类？分别有哪些？
   答：

   • 同步容器：

     Collections 类中有一些静态方法，可以基于普通容器返回线程安全的同步容器。比如：

     1 2 3

     public static <T> Collection<T> synchronizedCollection(Collection<T> c) public static <T> List<T> synchronizedList(List<T> list) public static<K, V> Map<K, V> synchronizedMap(Map<K, V> m)

    * **原理是给所有容器方法都加上 `synchronized` 来实现安全的**。
    * **同步容器的性能比较低**。
    * **在复合操作和迭代时，需要调用方手动使用 `synchronized` 同步，并注意不要同步错对象**。

* **并发容器**：

    **并发容器是专为并发设计的，线程安全、并发度高、性能更高、迭代不会抛出 `ConcurrentModificationException` 异常，很多容器以原子方式支持一些复合操作**。

    * **写时复制的 `List` 和 `Set`**：

        * **`CopyOnWriteArrayList`** 基于数组实现了 `List` 接口，**`CopyOnWriteArraySet`** 基于 `CopyOnWriteArrayList` 实现了 `Set` 接口。
        * 它们采用了**写时复制**，适用于读远多于写、集合不太大的场合；不适用于数组很大且修改频繁的场景。它们是以**优化读操作为目标**的，读不需要同步、性能很高，但在优化读的同时牺牲了写的性能。

    * **`ConcurrentHashMap`**：

        * **`HashMap` 不是线程安全的，在并发更新的情况下，`HashMap` 的链表结构可能形成环，出现死循环，占满 `CPU`**。
        * **`ConcurrentHashMap` 是并发版本的 `HashMap`**，通过细粒度锁和其他技术实现了高并发，读操作完全并行，写操作支持一定程度的并行，以原子方式支持一些复合操作，迭代不用加锁，不会抛出 `ConcurrentModificationException` 异常。

    * **基于跳表 `SkipList` 的 `Map` 和 `Set`**：

        * **`ConcurrentHashMap` 不能排序**，容器类中可以排序的 `Map` 和 `Set` 是 `TreeMap` 和 `TreeSet`，但它们不是线程安全的。**`Java` 并发包中与 `TreeMap/TreeSet` 对应的并发版本是 `ConcurrentSkipListMap` 和 `ConcurrentSkipListSet`**。
        * `ConcurrentSkipListMap` 是基于 `SkipList` 实现的，**`SkipList` 称为跳跃表或跳表，是一种底层单链表的多索引层的数据结构，主要操作复杂度是 `O(log2(N))`**。并发版本采用跳表而不是树，是因为**跳表更易于实现高效并发算法**。
        * **`ConcurrentSkipListMap` 没有使用锁，所有操作都是无阻塞的，所有操作都可以并行，包括写操作**。与 `ConcurrentHashMap` 类似，迭代器不会抛出 `ConcurrentModificationException` 异常，是弱一致的，也直接支持一些原子复合操作。

    * **各种队列**：

        * **各种阻塞队列主要用于协作，非阻塞队列适用于多个线程并发使用一个队列的场合**，有两个非阻塞队列：**`ConcurrentLinkedQueue`** 和 **`ConcurrentLinkedDeque`**。
        * `ConcurrentLinkedQueue` 实现了 `Queue` 接口，表示一个先进先出的队列；`ConcurrentLinkedDeque` 实现了 `Deque` 接口，表示一个双端队列。它们都是基于链表实现的，都没有限制大小，是无界的，这两个类最基础的实现原理是**循环 `CAS`，没有使用锁**。

1. 多线程的协作场景有哪些？试举例说明。
   答：生成者/消费者模式、主从协作模式、同时开始、集合点等待。

2. 线程的协作机制有哪些？谈谈你的理解。
   答：

   • wait()/notify()：

     • wait()/notify() 与 synchronized 配合一起使用，是线程的基本协作机制。
     • 每个对象都有一把锁和两个等待队列，一个是锁等待队列，里面放的是等待获取锁的线程；另一个是条件等待队列，里面放的是等待条件的线程：wait() 的作用是将自己加入条件等待队列，notify() 的作用是从条件等待队列上移除 一个线程并唤醒，notifyAll() 移除所有线程并唤醒。
     • wait()/notify() 方法只能在 synchronized 代码块内被调用。调用 wait() 时，线程会释放对象锁，被 notify()/notifyAll() 唤醒后，要重新竞争对象锁，获取到锁后才会从 wait() 调用中返回，返回后，不代表其等待的条件就一定成立了，需要重新检查其等待的条件。
     • wait()/nofity() 方法看上去简单，但往往难以理解 wait() 等的到底是什么，而 notify() 通知的又是什么，只能有一个条件等待队列，这也是 wait()/notify() 机制的局限性，这使得对于等待条件的分析变得复杂。

   • 显示条件：

     • 显示条件与显示锁配合使用，与 wait()/notify() 相比，可以支持多个条件队列，代码更为易读、效率更高。
     • 使用时注意不要将 signal()/signalAll() 误写为 notify()/notifyAll()。

   • 线程的中断：

     • Java 中取消/关闭一个线程的方式是中断。中断并不是强迫终止一个线程，它是一种协作机制，是给线程传递一个取消信号，由线程来决定如何以及何时退出。
     • 线程在不同状态和 IO 操作时对中断有不同的反应。作为线程的实现者，应该提供明确的取消/关闭方法，并用文档清楚描述其行为；作为线程的调用者，应该使用其取消/关闭方法，而不应该贸然调用 interrupt() 方法。

   • 协作工具类：

     • 除了基本的显示锁和条件，针对常见的协作场景，Java 并发包提供了多个用于协作的工具类。
     • 信号量类 Semaphore 用于限制对资源的并发访问数。
     • 倒计时门栓 CountDownLatch 主要用于不同角色线程间的同步。比如在裁判/运动员模式中，裁判线程让多个运动员线程同时开始，也可以用于协调主从线程，让主线程等待多个线程的结果。
     • 循环栅栏 CyclicBarrier 用于同一角色线程间的协调一致，所有线程在到达栅栏后都需要等待其他线程，等所有线程都到达后再一起通过。它是循环的，可以用作重复的同步。

   • 阻塞队列：

     • 对于最常见的生产者/消费者协作模式，可以使用阻塞队列。
       * 阻塞队列封装了锁和条件，生产者线程和消费者线程只需要调用队列的入队/出队方法就可以了，不需要考虑同步和协作问题。
     • 阻塞队列有普通的先进先出队列，包括基于数组的 ArrayBlockingQueue 和基于链表的 LinkedBlockingQueue/LinkedBlockingDeque，也有基于堆的优先级阻塞队列 PriorityBlockingQueue，还有可用于定时任务的延时阻塞队列 DelayQueue，以及用于特殊场景的阻塞队列 SynchronousQueue 和 LinkedTransferQueue。

   • Future/FutureTask：

     • 在常见的主从协作模式中，主线程往往是让子线程异步执行一项任务，获取其结果。手工创建子线程的写法往往比较麻烦，常见的模式是使用异步任务执行服务：不再手工创建线程，而只是提交任务，提交后马上得到一个结果，但这个结果不是最终结果，而是一个 Future。Future 是一个接口，主要实现类是 FutureTask。
     • Future 封装了主线程和执行线程关于执行状态和结果的同步，对于主线程而言，它只需要通过 Future 就可以查询异步任务的状态、获取最终结果、取消任务等，不需要再考虑同步和协作问题。

1. 多线程开发的两个核心问题？
   答：

   • 竞争和协作。
   • 管理竞争和协作是复杂的，所以 Java 提供了更高层次的服务，比如并发容器和异步任务执行服务。

2. 线程安全的机制有哪些？谈谈你的理解。
   答：线程表示一条单独的执行流，每个线程有自己的执行计数器，有自己的栈，但可以共享内存，共享内存是实现线程协作的基础。但共享内存有两个问题：竞态条件和内存可见性。解决这些问题的思路有：

   • synchronized：

     • synchronized 只是一个关键字，简单易用。在大部分情况下，放到类的方法声明上就可以了。既可以解决竞态条件问题，也可以解决内存可见性问题。
     • synchronized 保护的是对象，不是代码。只有对同一个对象的 synchronized 方法调用，synchronized 才能保证它们被顺序调用。对于实例方法，这个对象是 this；对于静态方法，这个对象是类对象；对于代码块，需要指定哪个对象。
     • synchronized 不能尝试获取锁，也不响应中断，还可能会死锁。不过，相比显式锁，synchronized 隐式锁简单易用，JVM 也可以不断优化它的实现。实际开发中，synchronized 应该被优先使用。

   • 显式锁：

     • 显式锁是相对于 synchronized 隐式锁而言的，它可以实现 synchronized 同样的功能，但需要程序员自己创建锁，调用锁相关的接口，主要接口是 Lock，主要实现类是 ReentrantLock。
     • 相比 synchronized，显式锁支持以非阻塞式方式获取锁、可以响应中断、可以限时、可以指定公平性、可以解决死锁问题，这使得显式锁灵活很多。
     • 在读多写少、读操作可以完全并行的场景中，可以使用读写锁以提高并发度，读写锁的接口是 ReadWriteLock，实现类是 ReentrantReadWriteLock。

   • volatile：

     • synchronized 和显式锁都是锁，使用锁可以实现安全，但使用锁是有成本的，获取不到锁的线程还需要等待，会有线程的上下文切换开销等。
     • 保证安全不一定非要锁。如果共享的对象只有一个，操作也只是进行最简单的 get()/set() 操作，set() 也不依赖于之前的值，那就不存在竞态条件问题，而只有内存可见性问题。这时，在变量的声明上加上 volatile 关键字就可以了。volatile 可以解决内存可见性问题。

   • 原子变量和 CAS：

     • 使用 volatile，set() 的新值不能依赖于旧值，但很多时候，set() 的新值与原来的值有关。这时，也不一定需要锁，如果需要同步的代码比较简单，可以考虑原子变量，它们包含了一些以原子方式实现组合操作的方法。对于并发环境中的计数、产生序列号等需求，考虑使用原子变量而非锁。
     • 原子变量的基础是 CAS，一般的计算机系统都在硬件层次上直接支持 CAS 指令。通过循环 CAS 的方式实现原子更新是一种重要的思维。相比 synchronized，它是乐观的，而 synchronized 是悲观的；它是非阻塞式的，而 synchronized 是阻塞式的。
     • CAS 是 Java 并发包的基础，基于它可以实现高效的、乐观的、非阻塞式的数据结构和算法。CAS 也是并发包中锁、同步工具和各种容器的基础。

   • 写时复制：

     • 之所以会有线程安全的问题，是因为多个线程并发读写同一个对象，如果每个线程读写的对象都是不同的，或者，如果共享访问的对象是只读的、不能修改，那也就不存在线程安全问题了。
     • 写时复制就是将共享访问的对象变为只读的，写的时候，再使用锁，保证只有一个线程写。写的线程不是直接修改原对象，而是新创建一个对象，对该对象修改完毕后，再原子性地修改共享访问的变量，让它指向新的对象。

   • ThreadLocal：

     • 线程本地变量 ThreadLocal 就是让每个线程，对同一个变量，都有自己的独有副本。每个线程实际访问的对象都是自己的，自然也就不存在线程安全问题了。

1. 怎样理解 ThreadLocal?
   答：

   • Java 中有一个特殊的概念：线程本地变量，这个概念在 Java 中的实现类就是 ThreadLocal，是一个泛型类。
   • 线程本地变量 ThreadLocal 的含义是：每个线程都有同一个变量的独有拷贝。

2. 【笔试题】试写出下面程序的运行结果并分析？

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   public class ThreadLocalBasic { static ThreadLocal<Integer> local = new ThreadLocal<> (); public static void main(String[] args) throws InterruptedException { Thread child = new Thread() { @Override public void run() { System.out.println("child thread initial: " + local.get()); local.set(200); System.out.println("child thread final: " + local.get()); } }; local.set(100); child.start(); child.join(); System.out.println("main thread final: " + local.get()); } }

答：

* 结果：

    
1
2
3
child thread initial: null
child thread final: 200
main thread final: 100



* 分析：主线程 `main` 对线程本地变量 `local` 的设置对子线程 `child` 不起作用，同样的，子线程 `child` 对线程本地变量 `local` 的改变也不会影响主线程 `main`。**二者访问的虽然是同一个变量 `local`，但每个线程都有自己的独立的值，这就是线程本地变量的含义**。

1. ThreadLocal 的主要方法有哪些？
   答：

   • ThreadLocal 是一个泛型类，接受一个类型参数 T，它只有一个空的构造方法。
   • public T get()：获取值，如果没有，返回 null。
   • public void set(T value)：设置值。
   • protected T initialValue()：提供初始值，是一个受保护方法，可以通过匿名内部类的方式提供。当调用 get() 方法时，如果之前没有设置过，会调用该方法获取初始值，默认实现是返回 null。
   • public void remove()：删掉当前线程对应的值，如果删掉后，再次调用 get()，会再调用 initialValue() 获取初始值。

2. 线程本地变量 ThreadLocal 的使用场景？
   答：

   • 日期处理。
   • 随机数。
   • 上下文信息。

3. Java 中的日期和时间操作类 DateFormat/SimpleDateFormat 不是线程安全的，那实现线程安全的方法有哪些？
   答：

   • 使用锁。
   • 每次都创建一个新的对象。
   • 更好的方式就是使用线程本地变量 ThreadLocal。

4. 【笔试题】手写一个 ThreadLocal 在日期处理的应用实现线程安全的 Demo？
   答：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   public class ThreadLocalDateFormat { static ThreadLocal<DateFormat> sdf = new ThreadLocal<DateFormat> () { // ThreadLocal 对象一般都定义为 static，便于引用 @Override protected DateFormat initialValue() { return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); } }; public static String date2String(Date date) { return sdf.get().format(date); } public static Date string2Date(String str) throws ParseException { return sdf.get().parse(str); } }

1. ThreadLocal 在随机数中是怎样应用的？
   答：

   • 即使对象是线程安全的，使用 ThreadLocal 也可以减少竞争。
   • Random 是线程安全的，但如果并发访问竞争激烈的话，性能会下降。
   • 所以，Java 并发包提供了类 ThreadLocalRandom，它是 Random 的子类，利用了 ThreadLocal。

2. ThreadLocal 在 上下文信息中的应用？
   答：

   • ThreadLocal 的典型用途是提供上下文信息。
   • 举个例子，在一个 Web 服务器中，一个线程执行用户的请求，在执行过程中，很多代码都会访问一些共同的信息，比如请求信息、用户身份信息、数据库连接、当前事务等。它们是线程执行过程中的全局信息，如果作为参数在不同代码间传递，代码会很烦琐。这时，使用 ThreadLocal 就很方便，所以被用于各种框架如 Sping 中。

3. 【笔试题】手写一个使用 ThreadLocal 保存上下文信息的 Demo？
   答：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   public class RequestContext { public static class Request { // …… } private static ThreadLocal<String> localUserId = new ThreadLocal<> (); private static ThreadLocal<Request> localRequest = new ThreadLocal<> (); public static String getCurrentUserId() { return localUserId.get(); } public static void setCurrentUserId(String userId) { localUserId.set(userId); } public static Request getCurrentRequest() { return localRequest.get(); } public static void setCurrentRequest(Request request) { localRequest.set(request); } }

1. ThreadLocal 的实现原理？
   答：分析源码可知：

   • 每个线程都有一个 Map（set() 方法内部会创建一个 map），类型为 ThreadLocalMap。
   • ThreadLocalMap 是一个内部类，是专门用于 ThreadLocal 的。与一般的 Map 不同，它的键类型为 WeakReference<ThreadLocal>，便于回收内存。
   • 对于每个 ThradLocal 对象，调用其 get()/set() 实际上就是以 ThreadLocal 对象为键读写当前线程的 Map。这样，就实现了每个线程都有自己的独立副本的效果。

2. 总结一下 Java 并发包中的一些同步协作工具？
   答：

   • 在读多写少的场景中使用 ReentrantReadWriteLock 代替 ReentrantLock，以提高性能。
   • 使用 Semaphore 限制对资源的并发访问数。
   • 使用 CountDownLatch 实现不同角色线程间的同步。
   • 使用 CyclicBarrier 实现同一角色线程间的协调一致。

3. 简单总结下 ThreadLocal?
   答：

   • ThreadLocal 使得每个线程对同一个变量有自己的独立副本，是实现线程安全、减少竞争的一种方案。
   • ThreadLocal 经常用于存储上下文信息，避免在不同代码间来回传递，简化代码。
   • 每个线程都要一个 Map，调用 ThreadLocal 对象的 get()/set() 方法实际上就是以 ThreadLocal 对象为键读写当前线程的该 Map。

1. 怎样理解循环栅栏 CyclicBarrier？
   答：

   • 相当于是一个栅栏，所有线程在到达该栅栏后都需要等待其他线程，等所有线程都到达后再一起通过。
   • 它是循环的，可以用作重复的同步。

2. 循环栅栏 CyclicBarrier 的使用场景？
   答：循环栅栏 CyclicBarrier 特别适用于并行迭代计算，每个线程负责一部分计算，然后在栅栏处等待其他线程完成，所有线程到齐后，交换数据和计算结果，再进行下一次迭代。

3. 异常 BrokenBarrierException 的含义是?
   答：

   • 循环栅栏 CyclicBarrier 的 await() 方法可能会抛出 BrokenBarrierException 异常。
   • 这个异常的意思是，在 CyclicBarrier 中，参与的线程是互相影响的，只要其中一个线程在调用 await() 时被中断了，或者超时了，栅栏就会被破坏。
   • 如果栅栏动作抛出了异常，栅栏也会被破坏。
   • 栅栏被破坏后，所有在调用 await() 的线程就会退出，抛出 BrokenBarrierException。

4. 【笔试题】手写一个 CyclicBarrier 应用 Demo?
   答：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

   // 多个游客分别在集合点 A 和 B 同步 public class CyclicBarrierDemo { static class Tourist extends Thread { CyclicBarrier barrier; public Tourist(CyclicBarrier barrier) { this.barrier = barrier; } @Override public void run() { try { // 模拟先各自独立运行 Thread.sleep((int) (Math.random() * 1000)); // 集合点 A barrier.await(); System.out.println(this.getName() + " arrived A " + System.currentTimeMillis()); // 集合后模拟再各自独立运行 Thread.sleep((int) (Math.random() * 1000)); // 集合点 B barrier.await(); System.out.println(this.getName() + " arrived B " + System.currentTimeMillis()); } catch(InterruptedException e) { } catch(BrokenBarrierException e) { } } } public static void main(String[] args) { int num = 3; Tourist[] threads = new Tourist[num]; CyclicBarrier barrier = new CyclicBarrier(num, new Runnable() { @Override public void run() { System.out.println("all arrived " + System.currentTimeMillis() + " executed by " + Thread.currentThread().getName()); } }); for(int i=0; i<num; i++) { threads[i] = new Tourist(barrier); threads[i].start(); } } }

1. 循环栅栏 CyclicBarrier 和 倒计时门栓 CountDownLatch 的区别？
   答：
   • 倒计时门栓 CountDownLatch 的参与线程是有不同角色的，有的负责倒计时，有的在等待倒计时变为 0，负责倒计时和等待倒计时的线程都可以有多个，用于不同角色线程间的同步。
   • 循环栅栏 CyclicBarrier 的参与线程角色是一样的，用于同一角色线程间的协调一致。
   • 倒计时门栓 CountDownLatch 是一次性的，循环栅栏 CyclicBarrier 是可以重复利用的。

1. 怎样理解倒计时门栓 CountDownLatch？
   答：

   • 作用就相当于现实生活中的门栓，一开始是关闭的，所有希望通过该门的线程都需要等待，然后开始倒计时，倒计时变为 0 后，门栓打开，等待的所有线程都可以通过。
   • 不同的是，它是一次性的，打开后就不能再关上了。

2. 门栓的两种应用场景？
   答：

   • 一种是同时开始，一种是主从协作。
   • 它们都有两类线程，互相需要同步。

3. 【笔试题】使用 CountDownLatch 实现同时开始（运动员比赛）场景？
   答：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

   public class RacerWithCountDownLatch { static class Racer extends Thread { CountDownLatch latch; public Racer(CountDownLatch latch) { this.latch = latch; } @Override public void run() { try { this.latch.await(); System.out.println(getName() + " start run " + System.currentTimeMillis()); } catch(InterruptedException e) { } } } public static void main(String[] args) throws InterruptedException { int num = 10; CountDownLatch latch = new CountDownLatch(1); Thread[] racers = new Thread[num]; for(int i=0; i<num; i++) { racers[i] = new Racer(latch); racers[i].start(); } Thread.sleep(1000); latch.countDown(); } }

1. 【笔试题】使用 CountDownLatch 实现主从协作（主线程等待工作线程结束）场景？
   答：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

   public class MasterWorkerDemo { static class Worker extends Thread { CountDownLatch latch; public Worker(CountDownLatch latch) { this.latch = latch; } @Override public void run() { try { // 模拟执行任务 Thread.sleep((int) (Math.random() * 1000)); // 模拟异常情况 if(Math.random() < 0.2) { throw new RuntimeException("bad luck"); } } catch(InterruptedException e) { } finally { this.latch.countDown(); // 确保在工作线程发生异常的情况下也会被调用，使主线程能够从 await() 调用中返回 } } } public static void main(String[] args) throws InterruptedException { int workerNum = 100; CountDownLatch latch = new CountDownLatch(workerNum); Worker[] workers = new Worker[workerNum]; for(int i=0; i<workerNum; i++) { workers[i] = new Worker(latch); workers[i].start(); } latch.await(); System.out.println("collect worker results"); } }