Java框架并发编程中有哪些常用设计模式？

并发编程中常用的设计模式有：executor：简化线程管理，管理线程池并提交任务。future：允许在任务完成前访问结果或取消任务，以表示异步执行的任务。completablefuture：增强了 future，异步过程构建功能提供了更复杂的功能。semaphore：限制同时访问特定资源的线程数量，防止资源过载。threadlocal：为每个线程提供私有数据存储，避免线程安全问题。

Java 常见的框架并发编程设计模式

并发编程在 Java 框架非常重要，需要有效地协调并行任务。以下是一些可用于简化和有效实现并发代码的最常用设计模式：

Executor

立即学习“Java免费学习笔记(深入)；

• 使用：管理线程池并提交任务。
• 优点：线程管理抽象，提供动态扩展和优化性能的方法。
• 示例：

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> System.out.println("Task completed"));

Future

• 用途：表示异步执行任务。
• 优点：允许在任务完成前访问结果或取消任务。
• 示例：

Future<String> future = executor.submit(() -> "Task result");
String result = future.get();

CompletableFuture

• 用途:增强 Future，它提供了组合和转换任务等更多的并发功能。
• 优点：允许复杂的异步过程轻松构建。
• 示例：

CompletableFuture<String> future = new CompletableFuture<>();
executor.submit(() -> {
    String result = "Task result";
    future.complete(result);
});

Semaphore

• 用途：限制同时访问特定资源的线程数量。
• 优点：防止资源超载，确保公平访问。
• 示例：

Semaphore semaphore = new Semaphore(10); // 允许 10 同时访问一个线程
semaphore.acquire(); // 获得许可证
try {
    // 访问资源
} finally {
    semaphore.release(); // 释放许可证
}

ThreadLocal

• 用途：为每个线程提供自己的私人数据存储。
• 优点：避免线程安全问题，轻松访问特定的线程数据。
• 示例：

ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("Thread-specific data");
String data = threadLocal.get();

实战案例：并发文件读取

以下是一个用途 Executor 和 Future 模式读取文件并发案例：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.*;

public class FileLinesReader {

    private static final int NUM_THREADS = 10;

    public static void main(String[] args) throws IOException, InterruptedException {
        Path path = Paths.get("input.txt");
        ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);

        List<Future<List<String>>> futures = submitFileLinesProcessing(executor, path);
        List<String> lines = collectFileLines(futures);

        for (String line : lines) {
            System.out.println(line);
        }
    }

    private static List<Future<List<String>>> submitFileLinesProcessing(
            ExecutorService executor, Path path) throws IOException {
        List<Future<List<String>>> futures = new ArrayList<>();

        for (int i = 0; i < NUM_THREADS; i++) {
            futures.add(executor.submit(() -> Files.readAllLines(path)));
        }

        return futures;
    }

    private static List<String> collectFileLines(
            List<Future<List<String>>> futures) throws InterruptedException, ExecutionException {
        List<String> lines = new ArrayList<>();

        for (Future<List<String>> future : futures) {
            lines.addAll(future.get());
        }

        return lines;
    }
}

Java框架并发编程中常用的设计模式有哪些？详情请关注图灵教育的其他相关文章！