Java常用的多线程编程

以下是Java多线程编程的主要方式及其在企业中的典型应用场景和代码示例：

---

1. 继承 Thread 类

应用场景：

继承 Thread 类适合一些简单的异步任务，比如在此例中的日志记录。通过创建一个新线程来处理日志记录任务，可以让主线程继续执行而不被阻塞。

这种方式在开发快速原型时非常方便，但在实际企业开发中不太推荐，因为每次创建线程会产生一定的开销，且难以管理大量的线程。

如果在企业开发中，存在大量并发任务的场景，建议使用线程池（ExecutorService）配合实现 Runnable 接口的方式来管理线程。线程池能够更高效地管理线程的创建、销毁等，避免了频繁创建线程带来的性能问题。

示例：异步记录日志（实际企业开发建议用ExecutorService配合Runnable）。

// 定义一个 LoggingThread 类，它继承自 Thread 类
public class LoggingThread extends Thread {
    
    // 定义一个成员变量，用于存储日志信息
    private String logMessage;

    // 构造函数，接收日志信息并初始化 logMessage
    public LoggingThread(String logMessage) {
        this.logMessage = logMessage;
    }

    // 重写 run() 方法，run 方法中定义线程需要执行的任务
    @Override
    public void run() {
        // 输出当前线程的名称和日志信息
        System.out.println(Thread.currentThread().getName() + ": " + logMessage);
    }

    // main 方法，程序入口
    public static void main(String[] args) {
        // 创建一个新的 LoggingThread 对象，并启动它
        new LoggingThread("User login succeeded").start();
    }
}

2. 线程池(ExecutorService) + 实现 Runnable 接口

为什么要使用线程池？

线程池在高并发场景下能有效管理和复用线程资源，避免频繁地创建和销毁线程。以下是线程池的一些优点：

• 性能提升：线程池复用了线程，避免了频繁的线程创建销毁带来的性能开销。
• 资源管理：线程池有一个最大线程数的限制，可以避免过多线程同时运行导致的资源耗尽。
• 简化代码：通过线程池提交任务时，系统会自动处理任务的分配和线程的调度，开发者只需要关注任务的执行逻辑。

应用场景：

高并发HTTP请求处理（利用线程池管理资源）。

通过线程池的管理，我们能够控制并发处理的数量，确保处理能力不会超出系统的承载范围，同时提高系统的响应速度和资源利用率。在高并发的场景中，线程池是一种非常重要的技术，广泛应用于 Web 服务器、消息队列等系统中。

示例：使用 ExecutorService 处理Web请求。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class HttpRequestHandler implements Runnable {
    // 请求内容
    private final String request;

    // 构造函数，接收一个请求
    public HttpRequestHandler(String request) {
        this.request = request;
    }

    // run 方法中定义处理请求的具体业务逻辑
    @Override
    public void run() {
        // 输出当前线程的名字和正在处理的请求
        System.out.println(Thread.currentThread().getName() + " processing: " + request);
    }

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，最多允许4个线程同时执行
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        // 模拟有10个HTTP请求需要处理
        for (int i = 0; i < 10; i++) {
            // 提交任务到线程池，每个任务都是一个HttpRequestHandler实例
            executor.execute(new HttpRequestHandler("Request-" + i));
        }
        
        // 关闭线程池，等待所有任务完成后再关闭
        executor.shutdown();
    }
}

---

3. Callable + Future 获取结果

一般这种方式适用于需要多个计算任务并行执行并汇总结果的场景。

应用场景：并行计算并汇总结果（如订单金额计算）。
示例：通过并发执行两个异步任务（获取商品价格和运费），进行后续计算，提高了程序的效率。

import java.util.concurrent.*; // 导入并发包，包含线程池、Future等类

public class OrderCalculator {
    public static void main(String[] args) throws Exception {
        // 创建一个固定大小为2的线程池，意思是最多只能同时处理两个任务
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交一个异步任务来计算商品的价格，返回的结果是一个 Future 对象
        //  Lambda 表达式，实现了 Callable<Double> 接口的匿名函数，隐式使用了 Callable
        Future<Double> priceFuture = executor.submit(() -> getProductPrice());

        /* Callable<Double> priceTask = new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                return getProductPrice();
            }
        };
        Future<Double> priceFuture = executor.submit(priceTask); */

        // 提交另一个异步任务来计算运费，同样返回一个 Future 对象，允许你后续再获取任务的结果。
        Future<Double> shippingFuture = executor.submit(() -> getShippingFee());

        /* Callable<Double> shippingTask = new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                return getShippingFee();
            }
        };
        Future<Double> shippingFuture = executor.submit(shippingTask); */

        // 通过调用 Future 对象的 get() 方法来获取计算结果，这会等待任务完成
        // get() 方法是阻塞的，也就是说会等待直到任务完成并返回结果
        Double total = priceFuture.get() + shippingFuture.get();

        // 打印计算出来的总费用
        System.out.println("Total cost: " + total);

        // 关闭线程池，释放资源
        executor.shutdown();
    }

    // 模拟获取商品价格的方法
    private static Double getProductPrice() {
        return 499.99; // 返回一个固定的商品价格
    }

    // 模拟获取运费的方法
    private static Double getShippingFee() {
        return 20.0; // 返回一个固定的运费
    }
}

4. CompletableFuture 异步编排

• CompletableFuture 是 Java 8 引入的异步编程工具，它增强了 Future 的功能，提供了更加简洁和灵活的异步处理方式。
• 它是 Future 的一个扩展，可以支持非阻塞的异步编程，并且提供了丰富的组合和回调功能。

优势：

• 并行执行：CompletableFuture 允许并行执行多个任务，并在任务完成后汇总结果，避免了串行调用带来的性能问题。
• 代码清晰简洁：通过流式操作（如 thenCombine 和 thenAccept）简化了异步编排的代码结构，使其更易于理解和维护。
• 异步编排：通过 CompletableFuture，我们能够方便地管理和组合多个异步操作，减少了 callback hell 的复杂性。

应用场景：组合多个微服务调用（如用户信息聚合）。

模拟一个典型的微服务场景：用户信息和订单信息的聚合。在微服务架构下，通常用户的信息和订单的列表是由不同的服务提供的，这些服务需要并行调用，以提高系统的响应速度。使用 CompletableFuture 使得这些操作能够并行执行并在结果准备好时进行处理。
示例：异步获取用户基本信息和订单列表。

import java.util.concurrent.CompletableFuture;

public class UserService {
    public static void main(String[] args) {
        // 使用 CompletableFuture.supplyAsync 异步获取用户基本信息
        CompletableFuture<String> userInfo = CompletableFuture.supplyAsync(() -> getUserInfo());
        
        // 使用 CompletableFuture.supplyAsync 异步获取订单列表
        CompletableFuture<String> orders = CompletableFuture.supplyAsync(() -> getOrderList());

        // 使用 thenCombine 组合两个 CompletableFuture 结果
        // 当 userInfo 和 orders 都完成时，会调用 lambda 表达式
        // 这个表达式将两个结果（info 和 order）拼接成一个字符串
        userInfo.thenCombine(orders, (info, order) -> "User: " + info + ", Orders: " + order)
                // 使用 thenAccept 处理拼接结果，这里输出到控制台
                .thenAccept(System.out::println)
                // join() 等待所有异步操作完成
                .join();
    }

    // 模拟从服务获取用户信息
    private static String getUserInfo() {
        return "Alice";  // 返回用户基本信息
    }

    // 模拟从服务获取订单列表
    private static String getOrderList() {
        return "[Order1, Order2]";  // 返回用户的订单列表
    }
}

thenCombine()：

thenCombine() 是一个很有用的操作，它用于将两个 CompletableFuture 结果进行组合。
只有在两个 CompletableFuture 都完成时，才会调用该方法。在这个例子中，userInfo 和 orders 都完成后，它会将返回的两个结果（info 和 order）合并成一个字符串：“User: Alice, Orders: [Order1, Order2]”。
thenCombine() 方法接受两个参数：
userInfo 和 orders 的结果（分别是 info 和 order），通过 lambda 表达式传入。
该方法的返回值是一个新的 CompletableFuture，该值表示组合后的结果。

thenAccept()：

thenAccept() 是一个后续操作，它接受一个 Consumer 函数接口。这里的作用是对 thenCombine 返回的结果进行消费，通常是进行打印、保存或者其他处理操作。
在此例中，thenAccept() 直接打印拼接后的结果："User: Alice, Orders: [Order1, Order2]"。

join()：

join() 方法会等待当前 CompletableFuture 完成。即使是在异步执行时，主线程会因为 join() 被阻塞，直到 thenAccept() 完成所有操作后才会继续执行。 该方法的作用是确保整个程序在主线程退出前，所有异步操作都已完成。

---

对比总结

特性	Callable + Future	线程池（ExecutorService） + Runnable	CompletableFuture
任务返回值	可以返回值	无返回值	可以返回值，支持链式操作
阻塞性	Future.get() 阻塞调用线程	无阻塞（没有结果返回）	非阻塞，可以进行异步链式操作
异常处理	通过 Future.get() 处理异常	无异常处理机制，异常必须捕获	支持 exceptionally() 异常处理
任务组合	不能直接组合多个任务	无法组合多个任务	可以通过 thenCombine(), thenApply() 等组合任务
使用场景	需要获取任务结果，且支持异常处理的场景	不需要任务结果的场景	需要组合多个异步任务且简洁的场景
代码复杂度	较为复杂，需要显式的处理返回值和阻塞	简单直接，但没有返回值	更加简洁、优雅，支持链式调用
性能	性能较好，但有阻塞等待	性能好，但没有结果返回	性能较好，且支持非阻塞，适合复杂的异步任务

---

5. 定时任务 ScheduledExecutorService

应用场景：

周期性任务： 这种定时任务非常适合用来做周期性的状态检查或数据清理，例如：缓存清理、定时备份、资源回收等。

系统健康检查： 可以每隔一定时间检查系统的状态，例如数据库连接的有效性、磁盘空间的使用情况等。
示例：每5秒执行一次缓存清理。

import java.util.concurrent.Executors;  // 导入Executors类，用于创建执行服务
import java.util.concurrent.ScheduledExecutorService;  // 导入ScheduledExecutorService接口，用于处理定时任务
import java.util.concurrent.TimeUnit;  // 导入TimeUnit类，用于表示时间单位

public class CacheCleaner {
    public static void main(String[] args) {
        // 创建一个ScheduledExecutorService实例，使用单线程的线程池（内含1个线程）来执行任务
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        
        // 使用scheduleAtFixedRate方法安排一个周期性任务，任务每隔指定时间重复执行
        scheduler.scheduleAtFixedRate(
            () -> {
                // 任务内容：打印“清理缓存...”的提示信息
                System.out.println("Cleaning cache...");
            },
            0,  // 初始延迟：表示任务开始前的等待时间，单位是秒。0表示立即开始执行。
            5,  // 周期性延迟：表示任务执行的时间间隔，这里是每5秒执行一次。
            TimeUnit.SECONDS  // 时间单位：指定时间的单位是秒
        );
    }
}

---

6. Fork/Join 框架

简介：ForkJoinPool 是 Java 7 引入的一个并行处理框架，旨在帮助解决大规模并行任务。通过将任务拆分为子任务并利用多个处理器同时执行，可以加速计算过程。ForkJoinPool 的核心思想是“分治”（Divide and Conquer），将大任务拆分为多个子任务，分别处理并合并结果。

优势：

• 分治算法：它特别适合处理可以被递归拆分的小任务，像数组求和、矩阵乘法等问题。
• 高效利用多核处理器：通过拆分任务和利用 ForkJoinPool，可以显著提高多核 CPU 上的并行计算性能。

应用场景：大规模数据处理（如分治求和）。
示例：并行计算大数组的和。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class ArraySumTask extends RecursiveTask<Long> {
    // 设置任务拆分的阈值，只有当数据量小于等于这个阈值时才会进行直接计算
    private static final int THRESHOLD = 1000;
    // 用于存储数组
    private final int[] array;
    // 当前任务需要处理的数组的起始索引
    private final int start;
    // 当前任务需要处理的数组的结束索引（不包括该索引）
    private final int end;

    // 构造函数，初始化任务的相关参数
    public ArraySumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        // 判断当前任务处理的数组长度是否已经小于等于阈值
        if (end - start <= THRESHOLD) {
            // 如果小于等于阈值，直接对数组进行求和
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // 如果数组长度大于阈值，将任务拆分为两个子任务
            int mid = (start + end) / 2; // 计算中间位置
            ArraySumTask left = new ArraySumTask(array, start, mid);  // 左子任务：处理前半部分
            ArraySumTask right = new ArraySumTask(array, mid, end);   // 右子任务：处理后半部分
            
            left.fork(); // 异步执行左子任务（将其放入线程池）
            return right.compute() + left.join(); // 先计算右子任务，然后等待左子任务的结果，并合并结果
        }
    }

    public static void main(String[] args) {
        // 创建一个大小为10,000的数组，并赋值为1到10,000的数字
        int[] array = new int[10_000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1; // 数组元素从1到10,000
        }

        // 创建ForkJoinPool对象来执行任务
        ForkJoinPool pool = new ForkJoinPool();
        // 使用ForkJoinPool来执行根任务，并返回结果
        long sum = pool.invoke(new ArraySumTask(array, 0, array.length));
        
        // 输出计算结果
        System.out.println("Sum: " + sum); // 输出 50005000
    }
}

compute 方法：

• 这是 RecursiveTask 中需要实现的核心方法，用于执行任务。
• 如果当前任务处理的数组大小小于等于阈值 THRESHOLD，则直接进行求和操作。
• 如果当前任务处理的数组大小大于 THRESHOLD，则将任务拆分成两个子任务，分别处理数组的前后两部分。使用 fork 异步执行左子任务，然后同步执行右子任务，并等待左子任务的结果（join）。最终，合并左右两个子任务的结果。

---

总结：

• 线程池（ExecutorService） 是企业中最常用的多线程管理方式，资源可控且高效。
• CompletableFuture 适合复杂的异步任务编排，如微服务调用聚合。
• 定时任务 使用 ScheduledExecutorService 而非 Timer，避免单点故障。
• Fork/Join 适用于可分治的大规模计算任务，但需评估任务拆分成本。