Java多线程与线程池技术详解（八）

《星游记》 “如果只有傻瓜才相信梦想，那么就叫我大傻瓜吧！”

《一人之下》 “想走的路不好走，想做人不好做，都说是身不由己，不是废话么。己不由心，身又岂能由己！”

---

目录

上一篇博客习题讲解

编写一段程序，演示如何使用 ReentrantLock 实现简单的生产者-消费者模式

分析并解释为什么在某些情况下 ReentrantLock 的性能会优于 synchronized

设计一个场景，说明何时应该选择使用读写锁而不是普通的互斥锁

实现一个简单的银行账户类，包含存款、取款方法，并保证线程安全

探讨公平锁和非公平锁各自的优缺点，并给出具体的应用实例

应用实例：

第8章 结束线程与线程池任务

8.1 stop() 与 destroy()

8.2 状态值结束线程

8.3 shutdown() 与 shutdownNow()

8.4 线程休眠

8.5 线程中断

8.6 Future 与 FutureTask

8.6.1 取消任务

8.6.2 任务超时结束

8.7 项目案例：所有线程池任务暂停与重启

8.8 本章习题

---

上一篇博客习题讲解

Java多线程与线程池技术详解（七）

https://blog.csdn.net/speaking_me/article/details/144368977?spm=1001.2014.3001.5501

编写一段程序，演示如何使用 ReentrantLock 实现简单的生产者-消费者模式

在Java中实现生产者-消费者模式时，我们可以使用ReentrantLock来控制对共享资源（如缓冲区）的访问。下面是一个简单的例子：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class ProducerConsumerExample {private final Queue<Integer> queue = new LinkedList<>();private final int LIMIT = 5; // 容器最多容纳的商品数量private final Lock lock = new ReentrantLock();private final Condition notFull = lock.newCondition();private final Condition notEmpty = lock.newCondition();public void produce() throws InterruptedException {while (true) {lock.lock();try {while (queue.size() == LIMIT) {System.out.println("仓库已满，等待...");notFull.await();}int product = (int) (Math.random() * 10);queue.offer(product);System.out.println("生产者生产了：" + product);notEmpty.signalAll();} finally {lock.unlock();}Thread.sleep(1000); // 模拟生产时间}}public void consume() throws InterruptedException {while (true) {lock.lock();try {while (queue.isEmpty()) {System.out.println("仓库为空，等待...");notEmpty.await();}int product = queue.poll();System.out.println("消费者消费了：" + product);notFull.signalAll();} finally {lock.unlock();}Thread.sleep(1000); // 模拟消费时间}}
}

这段代码展示了如何使用ReentrantLock和Condition对象来同步生产者和消费者的活动。

分析并解释为什么在某些情况下 ReentrantLock 的性能会优于 synchronized

根据实际测试，在高并发的情况下，ReentrantLock的性能通常优于synchronized。这是因为ReentrantLock提供了更多的功能，例如公平锁、非阻塞锁获取尝试（如tryLock()）、以及锁中断等特性。这些额外的功能使得开发者可以根据具体的应用场景优化线程的行为，从而提高系统的整体效率。

此外，ReentrantLock允许程序员更精细地控制锁的获取与释放，这有助于减少不必要的上下文切换，进而提升性能。例如，可以将锁的范围缩小到最小必要的部分，避免长时间持有锁造成的瓶颈。相比之下，synchronized关键字则总是锁定整个方法或代码块，可能会导致更高的竞争开销。

设计一个场景，说明何时应该选择使用读写锁而不是普通的互斥锁

假设我们有一个缓存系统，其中数据主要是用来查询的，而更新操作相对较少。在这种情况下，如果多个线程同时进行读取操作，则没有必要阻止它们；只有当有写入请求到来时，才需要确保独占访问以防止数据不一致的问题。因此，这里非常适合采用读写锁(ReentrantReadWriteLock)来代替传统的互斥锁。

通过这种方式，我们可以让多个读线程并发执行，而在写入期间阻止所有其他类型的访问，这样既保证了数据的一致性，又提高了系统的吞吐量。

实现一个简单的银行账户类，包含存款、取款方法，并保证线程安全

对于银行账户类，我们可以分别用synchronized和ReentrantLock两种方式来保证线程安全。以下是基于ReentrantLock的实现示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;class BankAccountWithReentrantLock {private double balance = 0;private final Lock lock = new ReentrantLock();private final Condition sufficientBalance = lock.newCondition();public void deposit(double amount) {lock.lock();try {balance += amount;System.out.println(Thread.currentThread().getName() + " 存款成功，余额为：" + balance);sufficientBalance.signalAll(); // 唤醒等待取款的线程} finally {lock.unlock();}}public void withdraw(double amount) throws InterruptedException {lock.lock();try {while (balance < amount) {System.out.println(Thread.currentThread().getName() + " 余额不足，等待存款...");sufficientBalance.await();}balance -= amount;System.out.println(Thread.currentThread().getName() + " 取款成功，余额为：" + balance);} finally {lock.unlock();}}
}

对比之下，使用synchronized的方式更加简洁，因为不需要显式地管理锁对象。然而，正如前面提到的，ReentrantLock提供了更多的灵活性和更好的性能表现，尤其是在高并发环境下。

探讨公平锁和非公平锁各自的优缺点，并给出具体的应用实例

公平锁意味着每个等待中的线程按照请求锁的时间顺序依次获得锁。这种机制虽然能保证线程间的公平性，但也可能导致较低的吞吐量，因为每次都需要检查队列中的下一个线程是否应该被授予锁。而非公平锁则允许新到达的线程直接尝试获取锁，即使已经有其他线程正在等待。这样做可以显著提高吞吐量，但可能会造成饥饿现象——即某些线程长期得不到服务。

应用实例：

非公平锁：在一个高频交易系统中，为了最大化交易处理的速度，可以选择非公平锁。尽管偶尔会有线程得不到立即响应，但是大多数情况下，快速进入临界区的能力将极大促进系统的响应速度。例如，在这样的环境中，每一个微秒的延迟都可能影响到交易的结果和公司的收益。因此，使用非公平锁可以减少线程在等待队列中的时间，使得更多的交易能够在更短的时间内完成。这不仅提高了系统的吞吐量，还增强了市场的竞争力。此外，由于高频交易通常涉及大量的并发操作，非公平锁可以通过允许新到来的线程直接竞争锁来避免不必要的上下文切换，从而进一步优化性能。

公平锁：相反地，在一个任务调度系统中，如果希望确保每个任务都能及时得到处理而不至于无限期延迟，则更适合采用公平锁。即使这样会牺牲一些性能，但在这种情况下，公平性和可预测性往往更重要。例如，在批处理作业或后台任务管理系统中，任务的执行顺序可能是非常关键的。使用公平锁可以保证所有提交的任务按照它们到达的时间顺序被执行，防止任何单个任务因为其他任务频繁抢占资源而被长时间搁置。这对于那些对服务级别协议（SLA）有严格要求的应用程序尤为重要，比如金融服务中的账单处理或者电信行业的计费系统，其中任务的及时性和准确性是至关重要的。

第8章 结束线程与线程池任务

8.1 stop() 与 destroy()

在早期版本的Java中，Thread类提供了stop()和destroy()方法用于停止线程。然而，这些方法已经被弃用，并且从JDK 1.2开始不再推荐使用。stop()方法的问题在于它会突然终止线程，可能导致资源泄漏或对象处于不一致状态。例如，当一个线程持有锁时被强制停止，那么其他等待该锁的线程将永远无法获得这个锁，从而导致死锁。

至于destroy()方法，虽然其初衷是为了立即销毁一个线程，但它从未真正实现过，因为直接销毁一个正在运行的线程可能会留下未完成的工作，如文件未关闭、网络连接未释放等。因此，在现代Java编程实践中，我们应该避免使用这两种方法来结束线程，而是采用更安全的方式，比如通过设置标志位让线程自行退出循环，或者利用线程池提供的API来进行线程管理。

8.2 状态值结束线程

为了优雅地结束线程，通常我们会定义一个布尔变量作为线程的状态标志，用来指示线程是否应该继续执行。下面是一个简单的例子，展示了如何使用状态值来控制线程的生命周期：

public class MyTask implements Runnable {private volatile boolean running = true; // 使用volatile确保可见性@Overridepublic void run() {while (running) {try {// 执行一些工作...System.out.println("Working...");Thread.sleep(1000); // 模拟工作时间} catch (InterruptedException e) {Thread.currentThread().interrupt(); // 恢复中断状态break;}}System.out.println("Task finished.");}public void shutdown() {running = false;}
}

在这个例子中，我们可以通过调用shutdown()方法来通知线程停止工作，然后线程会在下一次检查状态时自然地退出循环。

8.3 shutdown() 与 shutdownNow()

ExecutorService接口提供了两种关闭线程池的方法：shutdown()和shutdownNow()。前者只会停止接收新的任务，并允许已经提交的任务继续执行完毕；而后者则试图立即停止所有正在执行的任务，并返回尚未开始的任务列表。需要注意的是，即使调用了shutdownNow()，也不能保证所有任务都会立刻停止，因为有些任务可能不会响应中断信号。

以下是关于这两个方法的一个简短示例：

import java.util.concurrent.*;public class ThreadPoolShutdownExample {public static void main(String[] args) throws InterruptedException {ExecutorService executor = Executors.newFixedThreadPool(2);// 提交几个任务for (int i = 0; i < 5; i++) {executor.submit(() -> {try {System.out.println(Thread.currentThread().getName() + " is working.");Thread.sleep(2000);} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName() + " was interrupted.");}});}// 关闭线程池executor.shutdown(); // 或者使用 executor.shutdownNow();// 等待所有任务完成if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {System.out.println("Tasks did not terminate in time.");}}
}

这段代码首先创建了一个固定大小为2的线程池，并向其中提交了五个任务。接着，根据选择调用shutdown()或shutdownNow()来尝试关闭线程池。最后，程序会等待最多60秒以确保所有任务都已完成。

8.4 线程休眠

线程休眠是使当前线程暂停执行一段时间的操作，这可以通过调用静态方法Thread.sleep(long millis)实现，其中millis是以毫秒为单位的时间长度。在此期间，线程不会占用CPU资源，也不会参与任何计算活动。一旦指定的时间过去，线程就会自动恢复执行。需要注意的是，如果在线程休眠期间发生中断异常（InterruptedException），我们应该适当地处理这个异常，通常是重新设置线程的中断状态。

try {Thread.sleep(1000); // 让当前线程休眠1秒
} catch (InterruptedException e) {Thread.currentThread().interrupt(); // 恢复中断状态
}

8.5 线程中断

线程中断是一种协作机制，允许一个线程请求另一个线程停止其所做的工作。要中断一个线程，可以调用它的interrupt()方法。被中断的线程可以在适当的时候检查自己的中断状态，并采取相应的行动。例如，如果线程正在调用sleep()、wait()或其他支持中断的方法，那么它会在检测到中断后抛出InterruptedException。此外，还可以通过调用Thread.interrupted()或isInterrupted()来手动查询线程的中断状态。

// 中断线程
thread.interrupt();// 在目标线程内部定期检查中断状态
if (Thread.currentThread().isInterrupted()) {// 清理资源并准备退出
}

8.6 Future 与 FutureTask

Future接口表示异步计算的结果，提供了获取结果、取消任务以及查询任务状态的方法。FutureTask是一个实现了Runnable和Future接口的具体类，它可以包装一个Callable对象，并允许将其提交给线程池执行。当任务完成后，可以通过调用get()方法来检索结果；如果任务还没有完成，则此方法会阻塞直到结果可用。此外，FutureTask还支持取消操作，即通过调用cancel(boolean mayInterruptIfRunning)来尝试取消任务。

import java.util.concurrent.*;public class FutureTaskExample {public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<Integer> task = () -> {// 模拟耗时操作Thread.sleep(5000);return 42;};FutureTask<Integer> futureTask = new FutureTask<>(task);Thread thread = new Thread(futureTask);thread.start();// 获取结果，如果任务还未完成，这里会阻塞Integer result = futureTask.get();System.out.println("Result: " + result);}
}

对于取消任务，如果我们希望尽可能快地停止任务，可以传递参数true给cancel()方法，这样不仅会标记任务为已取消，还会尝试中断正在执行的任务。但是请注意，并不是所有的任务都能响应中断，特别是那些长时间运行而不检查中断状态的任务。

8.6.1 取消任务

如前所述，Future接口提供了一个cancel(boolean mayInterruptIfRunning)方法，用于尝试取消正在进行的任务。如果任务已经开始执行并且mayInterruptIfRunning设为true，那么系统会尝试中断任务。不过，正如前面提到的，实际效果取决于任务本身是否正确处理了中断信号。如果任务没有及时响应中断，那么它可能仍然会继续执行一段时间。

8.6.2 任务超时结束

有时候我们需要限制任务的最大执行时间，以防止它们无限期地挂起。为此，Future接口提供了带有时限的get(long timeout, TimeUnit unit)方法。如果任务未能在规定时间内完成，将会抛出TimeoutException。此时，我们可以选择放弃任务或将它重新排队稍后再试。

try {Integer result = futureTask.get(3, TimeUnit.SECONDS);System.out.println("Result: " + result);
} catch (TimeoutException e) {System.out.println("Task timed out.");futureTask.cancel(true); // 尝试取消任务
}

8.7 项目案例：所有线程池任务暂停与重启

假设我们有一个场景，需要能够在特定条件下暂停所有线程池中的任务，并在条件满足时恢复它们。虽然Java的标准库并没有直接提供这样的功能，但我们可以通过自定义的方式来实现这一点。一种常见的做法是在每个任务内部添加逻辑来监听外部信号，例如使用CountDownLatch或CyclicBarrier等同步辅助工具。另一种方法是利用Semaphore来控制并发度，从而间接达到暂停的效果。

下面是一个基于Semaphore的例子，演示了如何暂停和恢复线程池中的任务：

import java.util.concurrent.*;public class PausingThreadPool {private final ExecutorService executor;private final Semaphore semaphore;public PausingThreadPool(int poolSize) {this.executor = Executors.newFixedThreadPool(poolSize);this.semaphore = new Semaphore(poolSize);}public void submit(Runnable command) {try {semaphore.acquire(); // 获取许可} catch (InterruptedException e) {Thread.currentThread().interrupt();return;}executor.submit(() -> {try {command.run();} finally {semaphore.release(); // 释放许可}});}public void pause() {semaphore.drainPermits(); // 清空所有许可}public void resume() {int permits = executor.getPoolSize();semaphore.release(permits); // 恢复所有许可}public void shutdown() {executor.shutdown();}public static void main(String[] args) throws InterruptedException {PausingThreadPool pool = new PausingThreadPool(2);// 提交任务for (int i = 0; i < 5; i++) {pool.submit(() -> {try {System.out.println(Thread.currentThread().getName() + " is working.");Thread.sleep(2000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}// 暂停任务pool.pause();System.out.println("Tasks paused.");// 等待几秒钟后恢复Thread.sleep(5000);pool.resume();System.out.println("Tasks resumed.");// 最终关闭线程池pool.shutdown();}
}

在这个例子中，我们创建了一个名为PausingThreadPool的类，它封装了一个普通的线程池，并通过Semaphore来控制任务的并发执行。当我们想要暂停任务时，只需调用pause()方法清空所有许可；当准备好恢复时，则调用resume()方法一次性释放足够的许可让所有等待的任务继续执行。这种方法有效地实现了任务的暂停与恢复功能，同时保持了原有线程池的行为不变。

8.8 本章习题

为了帮助您更好地理解和掌握本章内容，请尝试解答以下问题：

1. 编写一段程序，展示如何使用ReentrantLock实现生产者-消费者模式，并解释为什么在某些情况下ReentrantLock的表现优于synchronized。
2. 设计一个场景，说明何时应该选择使用读写锁而不是普通的互斥锁，并给出具体的理由。
3. 实现一个简单的银行账户类，包含存款、取款方法，并确保线程安全。分别使用synchronized和ReentrantLock来解决同步问题，比较两者的异同点。
4. 探讨公平锁和非公平锁各自的优缺点，并给出具体的应用实例。
5. 分析并解释为什么shutdown()和shutdownNow()之间存在差异，以及它们各自适用的情况是什么？
6. 讨论Future和FutureTask的作用，包括如何取消任务和处理任务超时的情况。
7. 创建一个小项目，模拟一个可以暂停和恢复所有线程池任务的系统，考虑如何实现这一功能以及可能遇到的问题。