Java多线程并发任务执行与性能基准测试指南

// 定义一个实现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("主线程已启动所有任务，并继续执行自身逻辑...");
        // 在这里主线程可以执行其他不依赖于子线程结果的操作
    }
}

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);
    }
}

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("所有并发任务执行完毕，主线程即将退出。");
    }
}

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任务执行完毕，主线程即将退出。");
    }
}