Java并发编程演进之路

嘿，Java开发者们！还记得刚学Java时写并发代码的痛苦吗？那时，我们得继承Thread类或实现Runnable接口，手动管理线程的创建与销毁。代码繁琐不说，一旦涉及大量线程，管理起来更是让人崩溃！比如，你可能写过这样的代码：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }
}


class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }
}


public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread runnableThread = new Thread(new MyRunnable());
        thread.start();
        runnableThread.start();
    }
}

是不是感觉特别复杂？每次写线程都得小心翼翼，生怕出错。

后来，Java引入了线程池，这无疑是一大进步！线程池可复用线程，降低了线程创建和销毁的开销，代码也简洁了许多。比如：

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


public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10 i int tasknumber='i;' executorservice.submit -> {
                System.out.println("Task " + taskNumber + " is running on " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}

线程池虽解决了不少问题，但在复杂并发场景下仍显不足。例如，线程的生命周期管理不够直观，错误处理繁琐。当同时发起多个网络请求时，手动管理每个线程的执行结果会让代码瞬间变得混乱。

小贴士：传统并发编程中，线程管理如同“走钢丝”，稍有不慎就会出错。

结构化并发：概念与核心原理

结构化并发是什么

想象一下，你正在开发一个电商系统，需要同时处理多个任务，如查询商品信息、计算订单总价、验证用户支付信息等。这些任务相互独立，却又同属处理订单这个大任务。要是能有一种方式，将这些任务有序组织起来，那该多好？

Java 21的结构化并发正是为此而生！它把并发任务组织成清晰的层次结构，类似一棵树，每个任务都可有自己的子任务。如此一来，任务间的关系一目了然，管理也变得轻松便捷。

举个例子，假设开发一个电商订单处理系统，处理订单的任务可拆分为以下子任务：

1.查询商品信息。2.计算订单总价。3.验证用户支付信息。

这些子任务都隶属于处理订单这个父任务，形成清晰的任务层次结构，任务关系清晰，管理方便。

核心原理剖析

任务层次结构

结构化并发将任务构建成层次分明的结构，如同树状，每个任务可包含多个子任务，子任务又能有自己的子任务。这种结构让任务间的关系清晰明了，便于管理和调度。

结果处理规则

在结构化并发里，子任务的结果只会返回给直接启动它们的父任务，不会随意传递给其他无关任务。这确保了任务间的数据流动有序且可预测。

生命周期绑定

子任务的生命周期不能超过其父任务。一旦父任务结束，所有未完成的子任务会被自动取消，有效避免了线程泄漏和资源浪费。

任务的协作与控制

父任务能依据子任务的执行情况，灵活决定是否继续执行其他子任务，或提前结束整个任务。这种协作与控制机制使并发任务的执行更高效、更智能。

小贴士：结构化并发就像给并发任务戴上了“紧箍咒”，让它们的执行更可控、更可预测。

Java 21结构化并发特性深度解析

上下文关联的任务创建

在Java 21的结构化并发中，上下文关联的任务创建是一项关键特性。它允许我们在特定代码块或作用域内创建并发任务，这些任务会自动与创建它们的上下文关联。当上下文结束时，相关任务会被自动清理，比如取消未完成的任务、收集任务执行结果等，极大地简化了任务管理的复杂性。

举个例子，假设开发一个Web应用程序，处理用户请求时需并发获取多个数据源的数据。使用Java 21的结构化并发，可这样实现：

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;


public class ContextualTaskCreationExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var userTask = scope.fork(() -> getUserInfo());
            var orderTask = scope.fork(() -> getOrderInfo());
            scope.join().throwIfFailed();
            String userInfo = userTask.resultNow();
            String orderInfo = orderTask.resultNow();
            System.out.println("User Info: " + userInfo);
            System.out.println("Order Info: " + orderInfo);
        }
    }


    private static String getUserInfo() {
        return "User: John Doe";
    }


    private static String getOrderInfo() {
        return "Order: 12345, Total: $100";
    }
}

在此例中，我们在try - with - resources语句块中创建了StructuredTaskScope.ShutdownOnFailure对象scope，它定义了任务执行的上下文。在该上下文中，通过scope.fork()方法创建了userTask和orderTask两个并发任务，分别用于获取用户信息和订单信息。当try - with - resources语句块结束时，scope会自动清理所有相关任务，确保无任务遗漏或泄漏。

小贴士：StructuredTaskScope是结构化并发的核心API之一，如同任务的“大管家”，帮你管理任务的生命周期和结果。

更好的异常传播机制

在并发编程中，异常处理一直是个难题。传统并发编程里，当一个并发任务抛出异常时，异常的传播和处理较为复杂，尤其是任务在不同线程中执行时，很难确保异常能被正确捕获和处理。

Java 21的结构化并发提供了更优的异常传播机制，使并发任务中的异常能得到更有效的管理。若一个子任务抛出异常，该异常会自动传播到其父任务，且整个任务结构会根据异常情况进行相应处理。

举个例子：

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;


public class ExceptionPropagationExample {
    public static void main(String[] args) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var task1 = scope.fork(() -> {
                if (Math.random() > 0.5) {
                    throw new RuntimeException("Task 1 failed");
                }
                return "Task 1 result";
            });
            var task2 = scope.fork(() -> "Task 2 result");
            scope.join();
            scope.throwIfFailed();
            String result1 = task1.resultNow();
            String result2 = task2.resultNow();
            System.out.println("Result 1: " + result1);
            System.out.println("Result 2: " + result2);
        } catch (InterruptedException | ExecutionException e) {
            System.err.println("An error occurred: " + e.getMessage());
        }
    }
}

在此例中，task1有可能抛出RuntimeException。当task1抛出异常时，task2会被自动取消，异常会传播到scope.join()处，通过throwIfFailed()方法抛出，最终被catch块捕获并处理。这样，我们就能在统一的地方处理并发任务中的异常，大幅提升了代码的健壮性和可维护性。

小贴士：结构化并发的异常处理机制就像给并发任务装上了“安全气囊”，让异常处理更简单、更可靠。

简化并发控制的API

Java 21的结构化并发提供了一系列更高级别的API，这些API极大地简化了并发控制的复杂性，让我们能更便捷地协调并发任务，减少手动同步和锁的使用，使并发逻辑更简洁清晰。

举个例子：

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;


public class SimplifiedConcurrencyControlExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            for (int i = 0; i < 5 i int tasknumber='i;' scope.fork -> {
                    System.out.println("Task " + taskNumber + " is running");
                    Thread.sleep((long) (Math.random() * 1000));
                    return "Task " + taskNumber + " result";
                });
            }
            scope.join().throwIfFailed();
            for (var subtask : scope.subtasks()) {
                String result = subtask.resultNow();
                System.out.println(result);
            }
        }
    }
}

在此例中，我们使用StructuredTaskScope创建了5个并发任务。通过scope.fork()方法可轻松启动每个任务，无需手动管理线程的创建和启动。scope.join()方法会等待所有任务完成，throwIfFailed()方法会检查是否有任务失败并抛出异常。最后，通过scope.subtasks()方法可获取每个任务的执行结果。这种方式让并发任务的控制和管理变得简单直观，大大减少了手动编写同步和锁代码的工作量。

小贴士：StructuredTaskScope的API就像并发任务的“瑞士军刀”，让并发控制更简单、更高效。

与虚拟线程的完美融合

Java 21引入的虚拟线程是一种轻量级线程实现，其创建和销毁开销极小，能在一个操作系统线程上运行大量虚拟线程，显著提升系统的并发处理能力。结构化并发与虚拟线程的结合，充分发挥了两者的优势，为高效并发编程提供了强大支持。

举个例子，假设开发一个高并发的网络爬虫应用，需要并发访问大量网页。使用虚拟线程和结构化并发，可这样实现：

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;


public class VirtualThreadsAndStructuredConcurrencyExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        var client = HttpClient.newHttpClient();
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            String[] urls = {
                "https://example.com",
                "https://google.com",
                "https://github.com"
            };
            for (String url : urls) {
                scope.fork(() -> {
                    var request = HttpRequest.newBuilder()
                          .uri(java.net.URI.create(url))
                          .build();
                    HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
                    return "URL: " + url + ", Status Code: " + response.statusCode();
                });
            }
            scope.join().throwIfFailed();
            for (var subtask : scope.subtasks()) {
                String result = subtask.resultNow();
                System.out.println(result);
            }
        }
    }
}

在此例中，我们使用虚拟线程并发访问多个URL。每个URL的访问任务通过scope.fork()方法创建，这些任务在虚拟线程中执行。由于虚拟线程的轻量级特性，我们可轻松创建大量任务，而不会对系统资源造成过大压力。同时，借助结构化并发的StructuredTaskScope，我们能方便地管理这些任务的生命周期和结果，确保所有任务正确执行并返回结果。这种结合方式使我们能高效处理高并发网络请求，提升应用程序的性能和响应速度。

小贴士：虚拟线程和结构化并发的结合，就像给并发编程装上了“超级加速器”，让高并发任务处理变得轻松自如。

代码示例：实战Java 21结构化并发

简单任务并发执行

下面通过一个简单示例展示如何使用Java 21的结构化并发实现多个任务的并发执行。假设我们有三个独立任务，每个任务模拟一个耗时操作并返回结果。

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;


public class SimpleConcurrentTasksExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var task1 = scope.fork(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "Task 1 result";
            });
            var task2 = scope.fork(() -> {
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "Task 2 result";
            });
            var task3 = scope.fork(() -> {
                try {
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "Task 3 result";
            });
            scope.join().throwIfFailed();
            System.out.println(task1.resultNow());
            System.out.println(task2.resultNow());
            System.out.println(task3.resultNow());
        }
    }
}

在此示例中，我们创建了StructuredTaskScope.ShutdownOnFailure对象scope，定义了任务执行范围。在该范围内，使用scope.fork()方法创建了task1、task2和task3三个并发任务。每个任务在独立线程中执行，并模拟了不同的耗时操作。

scope.join()方法会阻塞当前线程，直至所有子任务完成。throwIfFailed()方法会检查是否有任务执行失败，若有则抛出异常。最后，通过task1.resultNow()、task2.resultNow()和task3.resultNow()方法获取并打印每个任务的执行结果。

小贴士：结构化并发让并发任务管理如同“搭积木”，任务间关系一目了然。

复杂任务场景应用

在实际开发中，常遇到复杂任务场景，如多任务依赖、任务优先级控制等。下面通过一个示例展示如何在这些场景下使用Java 21的结构化并发。

假设开发一个电商数据分析系统，需要从多个数据源获取数据，然后进行汇总和分析。其中，获取用户数据和订单数据的任务相互独立，可并发执行，但生成报表的任务依赖于用户数据和订单数据的获取结果。

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.ExecutionException;


public class ComplexConcurrentTasksExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var userDataTask = scope.fork(() -> getUserData());
            var orderDataTask = scope.fork(() -> getOrderData());
            scope.join().throwIfFailed();
            String userData = userDataTask.resultNow();
            String orderData = orderDataTask.resultNow();
            var reportTask = scope.fork(() -> generateReport(userData, orderData));
            scope.join().throwIfFailed();
            String report = reportTask.resultNow();
            System.out.println(report);
        }
    }


    private static String getUserData() {
        return "User data: [User1, User2, User3]";
    }


    private static String getOrderData() {
        return "Order data: [Order1, Order2, Order3]";
    }


    private static String generateReport(String userData, String orderData) {
        return "Report: Analyzing user data: " + userData + " and order data: " + orderData;
    }
}

在此示例中，我们先创建了userDataTask和orderDataTask两个并发任务，分别用于获取用户数据和订单数据。通过scope.join().throwIfFailed()等待这两个任务完成，并获取结果。

接着，创建reportTask任务，它依赖于userDataTask和orderDataTask的结果，用于生成报表。最后，再次通过scope.join().throwIfFailed()等待报表生成任务完成，并获取报表结果进行打印。

通过这种方式，我们能清晰管理任务间的依赖关系，使复杂的并发任务逻辑更易于理解和维护。

小贴士：结构化并发就像并发任务的“指挥官”，让任务协作有条不紊。

结构化并发应用场景与优势

常见应用场景

oWeb开发：在处理用户请求时，经常需要并发地获取多个数据源的数据，然后进行整合和处理。结构化并发可以轻松地并发执行这些任务，提高页面的加载速度和用户体验。o大数据处理：在大数据处理中，常常需要对大量的数据进行并行计算和分析。结构化并发可以将数据处理任务拆分成多个子任务，每个子任务在独立的线程中执行，然后将结果合并，从而实现高效的数据处理。o分布式系统：在分布式系统中，各个节点之间的通信和协作往往是并发进行的。结构化并发可以更好地管理这些并发操作，确保数据的一致性和系统的稳定性。

相比传统并发的显著优势

o避免线程泄漏：结构化并发中，子任务的生命周期与父任务紧密绑定，当父任务结束时，所有未完成的子任务都会被自动取消，从而有效地避免了线程泄漏的发生。o降低死锁风险：结构化并发通过明确的任务层次结构和执行顺序，减少了死锁发生的可能性。o提高代码可读性和可维护性：结构化并发将并发任务组织成一个清晰的结构，使得代码的逻辑更加直观，易于理解和维护。o提升性能：通过与虚拟线程的结合，结构化并发能够充分利用虚拟线程的轻量级特性，在处理大量并发任务时，减少线程创建和上下文切换的开销，从而显著提升系统的性能和响应速度。

小贴士：结构化并发就像是并发编程的“升级版”，让代码不仅更简洁，还更安全、更高效。

总结与展望

Java 21的结构化并发为并发编程带来了重大的变革，它通过清晰的任务层次结构、更好的异常传播机制、简化的并发控制API以及与虚拟线程的完美融合，使得并发编程变得更加简单、可靠和高效。

在Web开发、大数据处理、分布式系统等众多领域，结构化并发都展现出了巨大的优势，能够帮助开发者更轻松地应对复杂的并发场景。

随着Java的不断发展，结构化并发有望成为并发编程的主流范式，为Java应用的性能和可靠性提供更强大的支持。我鼓励各位开发者积极尝试Java 21的结构化并发，将其应用到实际项目中，体验它带来的便利和优势。

如果你在使用Java 21结构化并发的过程中有任何问题、心得或体会，欢迎在留言区分享交流，让我们一起学习，共同进步！