本教程将指导您如何在Java中实现多个独立任务的并发执行，通过创建和管理线程来同时运行不同的计算密集型操作，例如素数筛选和暴力测试。我们将探讨使用Thread类进行线程管理，介绍性能基准测试的关键方法如System.nanoTime()和Thread.join()，并引出更高级的java.util.concurrent.ExecutorService框架，以构建高效、可控的并发程序。
在现代软件开发中，为了充分利用多核处理器性能，将独立的计算密集型任务并发执行已成为常见需求。例如，同时运行埃拉托斯特尼筛法（sieve of eratosthenes）和暴力破解（brute force）等算法，并在它们完成后报告各自的执行结果。java提供了强大的并发编程工具来实现这一目标。
使用Thread类实现基本并发
Java中最基础的并发实现方式是使用Thread类。每个Thread实例代表一个独立的执行流。要定义一个线程将要执行的任务，通常有两种方式：实现Runnable接口或继承Thread类。推荐实现Runnable接口，因为它允许任务类继承其他类，并且更好地分离了任务逻辑与线程管理。
考虑以下两个独立的任务。我们可以为它们分别创建一个Runnable实例，然后将这些实例传递给Thread对象并启动。为了代码的清晰性和可维护性，建议避免在方法内部直接创建匿名类来扩展Thread，而是定义一个具名的Runnable类或使用Lambda表达式。
// 定义一个实现Runnable接口的任务类 class MyConcurrentTask implements Runnable { private String taskName; private long simulatedWorkDuration; // 模拟工作时长，单位毫秒 public MyConcurrentTask(String taskName, long simulatedWorkDuration) { this.taskName = taskName; this.simulatedWorkDuration = simulatedWorkDuration; } @Override public void run() { System.out.println(taskName + " 正在执行..."); try { // 模拟耗时操作，例如复杂的计算或数据处理 Thread.sleep(simulatedWorkDuration); } catch (InterruptedException e) { // 捕获中断异常，并重新设置中断状态 Thread.currentThread().interrupt(); System.out.println(taskName + " 被中断。"); } System.out.println(taskName + " 执行完毕。"); } } public class BasicConcurrentExecution { public static void main(String[] args) { System.out.println("主线程启动并发任务..."); // 创建并启动两个独立的任务线程 Thread task1 = new Thread(new MyConcurrentTask("埃拉托斯特尼筛法测试", 2000)); Thread task2 = new Thread(new MyConcurrentTask("暴力破解测试", 2500)); task1.start(); // 启动线程 task1 task2.start(); // 启动线程 task2 System.out.println("主线程已启动所有任务，并继续执行自身逻辑..."); // 在这里主线程可以执行其他不依赖于子线程结果的操作 } }
上述示例中，我们通过创建一个实现Runnable接口的具名类MyConcurrentTask来定义任务逻辑，而不是在Thread构造器内部使用匿名类。这种方式提高了代码的可读性和可维护性。
精确的性能基准测试
在并发任务场景中，准确测量每个任务的执行时间至关重要。Java提供了System.nanoTime()方法用于高精度的时间测量。与System.currentTimeMillis()不同，nanoTime()返回的是jvm启动以来的纳秒级时间，它不依赖于系统时钟，因此更适合测量持续时间，尤其是在需要高精度或避免系统时钟调整影响的场景。
立即学习“Java免费学习笔记（深入）”；
为了在任务内部进行计时，我们可以在run()方法开始时记录起始时间，在结束时记录结束时间，并计算差值。
class BenchmarkingTask implements Runnable { private String taskName; private long simulatedWorkDuration; // 模拟任务持续时间，单位毫秒 public BenchmarkingTask(String taskName, long simulatedWorkDuration) { this.taskName = taskName; this.simulatedWorkDuration = simulatedWorkDuration; } @Override public void run() { long startTime = System.nanoTime(); // 记录开始时间（纳秒） System.out.println(taskName + " 开始执行..."); try { // 模拟耗时操作，例如Sieve of Eratosthenes或Brute Force算法 Thread.sleep(simulatedWorkDuration); } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.out.println(taskName + " 被中断。"); } long endTime = System.nanoTime(); // 记录结束时间（纳秒） long elapsedTimeNanos = endTime - startTime; // 将纳秒转换为秒，并保留四位小数 double elapsedTimeSeconds = (double) elapsedTimeNanos / 1_000_000_000.0; System.out.printf("%s 执行完毕，耗时：%.4f 秒%n", taskName, elapsedTimeSeconds); } }
等待线程完成：Thread.join()
当主线程启动了多个子线程后，通常需要等待所有子线程执行完毕，才能汇总结果或进行后续处理。Thread.join()方法允许一个线程等待另一个线程终止。当对一个线程对象调用join()方法时，当前线程（通常是主线程）会阻塞，直到被调用的线程完成其执行。
结合基准测试，我们可以在启动所有线程后，依次对每个线程调用join()，确保所有任务都已完成并报告了结果，然后主线程才能安全退出。
public class ConcurrentBenchmarking { public static void main(String[] args) { System.out.println("主线程启动并发任务..."); // 创建两个任务线程 Thread sieveThread = new Thread(new BenchmarkingTask("埃拉托斯特尼筛法", 2500)); Thread bruteForceThread = new Thread(new BenchmarkingTask("暴力测试", 3000)); // 启动线程 sieveThread.start(); bruteForceThread.start(); try { // 等待两个任务线程完成 sieveThread.join(); bruteForceThread.join(); } catch (InterruptedException e) { // 捕获中断异常，并重新设置中断状态 Thread.currentThread().interrupt(); System.err.println("主线程等待过程中被中断。"); } System.out.println("所有并发任务执行完毕，主线程即将退出。"); } }
注意事项： join()方法可能会抛出InterruptedException，因此需要进行捕获和处理。在捕获到中断异常时，最佳实践是重新设置当前线程的中断状态 (Thread.currentThread().interrupt();)，以便更高层的代码能够感知到中断。
更高级的并发管理：java.util.concurrent.ExecutorService
直接使用Thread类进行线程管理在简单场景下是可行的，但在面对大量任务、线程池管理、任务生命周期控制等复杂需求时，java.util.concurrent包提供了更强大、更灵活的工具，特别是ExecutorService。
ExecutorService是一个高级的并发API，它将任务提交与任务执行机制解耦。它允许我们提交Runnable或Callable任务，并由线程池来管理线程的创建、复用和销毁。这大大简化了并发编程，减少了资源开销，并提供了更好的控制。
以下是使用ExecutorService实现相同并发任务的示例：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class ExecutorServiceBenchmarking { public static void main(String[] args) { System.out.println("主线程使用ExecutorService启动并发任务..."); // 创建一个固定大小的线程池，例如2个线程，以匹配任务数量 ExecutorService executor = Executors.newFixedThreadPool(2); // 提交任务到线程池 executor.submit(new BenchmarkingTask("埃拉托斯特尼筛法", 2500)); executor.submit(new BenchmarkingTask("暴力测试", 3000)); // 关闭ExecutorService，不再接受新任务，但会等待已提交任务完成 executor.shutdown(); try { // 等待所有已提交任务完成，最多等待1分钟 if (!executor.awaitTermination(1, TimeUnit.MINUTES)) { System.err.println("部分任务未在指定时间内完成。"); } } catch (InterruptedException e) { // 如果主线程在等待过程中被中断，则尝试立即关闭所有正在执行的任务 executor.shutdownNow(); Thread.currentThread().interrupt(); System.err.println("主线程等待ExecutorService关闭过程中被中断。"); } System.out.println("所有ExecutorService任务执行完毕，主线程即将退出。"); } }
通过ExecutorService，我们不再需要手动创建和管理Thread对象，也不需要显式调用join()。executor.shutdown()会平滑地关闭线程池，不再接受新任务，但会等待已提交任务完成。executor.awaitTermination()则用于阻塞当前线程，直到所有任务完成或超时。
总结
在Java中实现并发任务执行，可以从基础的Thread和Runnable开始。为了进行准确的性能基准测试，应使用System.nanoTime()进行时间测量，并通过Thread.join()确保所有任务完成后再汇总结果。对于更复杂的并发场景和更好的资源管理，强烈推荐使用java.util.concurrent包中的ExecutorService等高级API。选择合适的并发工具，并遵循最佳实践，是构建高效、健壮的多线程应用程序的关键。
评论（已关闭）
评论已关闭