在现代软件开发中，为了充分利用多核处理器性能，将独立的计算密集型任务并发执行已成为常见需求。例如，同时运行埃拉托斯特尼筛法（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。选择合适的并发工具，并遵循最佳实践，是构建高效、健壮的多线程应用程序的关键。
