Java在不同版本中逐步增强了对多线程的支持，通过提供不同的API和工具，使得多线程编程更高效、易于管理。下面是各版本中重要的多线程相关特性及示例代码：
1. Java 1.0 - 线程基础（Thread类和Runnable接口）
Java最早在1.0版本中引入了多线程支持，提供了Thread类和Runnable接口。可以通过实现Runnable接口或继承Thread类来创建线程。
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running");
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable is running");
}
}
// 使用示例
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
Thread runnableThread = new Thread(new MyRunnable());
runnableThread.start();
}
}
2. Java 5 - 引入并发包（java.util.concurrent）
早期的Thread类和Runnable接口提供了基本的多线程能力，但缺乏高级管理和控制工具，开发者需要自己处理线程的创建、销毁以及资源管理。随着多线程需求增多，管理线程的复杂性也逐渐上升。因此，Java 5引入了Executor框架，提供了线程池和任务管理接口，简化了线程创建、资源重用和任务调度的流程，帮助开发者专注于业务逻辑，而不是底层线程管理。
Java 5 是多线程支持的一个重要升级，引入了java.util.concurrent包，提供了线程池、Callable接口、Future接口等，方便管理并发任务。ExecutorService接口使线程池更易用。
import java.util.concurrent.*;
public class ConcurrentExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
Callable<String> task = () -> {
Thread.sleep(1000);
return "Callable Result";
};
Future<String> future = executor.submit(task);
try {
System.out.println("Result: " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
executor.shutdown();
}
}
}
3. Java 7 - Fork/Join框架
随着多核CPU的普及，单线程计算逐渐无法满足性能需求。Java 7 引入的Fork/Join框架就是为了应对这一趋势。ForkJoinPool允许程序员将大型任务拆分成更小的子任务，并在多核处理器上并行处理，以充分利用多核性能。这一改进特别适用于需要高吞吐量和大规模数据处理的场景，比如并行排序和矩阵计算。
Java 7 引入了ForkJoinPool和ForkJoinTask，用于分而治之的任务，比如并行处理大型数据集。ForkJoinPool适合处理递归任务，并且可以自动利用多核CPU的性能。
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class ForkJoinExample extends RecursiveTask<Integer> {
private final int[] array;
private final int start, end;
public ForkJoinExample(int[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= 10) {
int sum = 0;
for (int i = start; i < end; i++) {
sum += array[i];
}
return sum;
} else {
int mid = (start + end) / 2;
ForkJoinExample leftTask = new ForkJoinExample(array, start, mid);
ForkJoinExample rightTask = new ForkJoinExample(array, mid, end);
leftTask.fork();
int rightResult = rightTask.compute();
int leftResult = leftTask.join();
return leftResult + rightResult;
}
}
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
int[] array = new int[100];
for (int i = 0; i < array.length; i++) array[i] = i;
ForkJoinExample task = new ForkJoinExample(array, 0, array.length);
int result = pool.invoke(task);
System.out.println("Sum: " + result);
}
}
4. Java 8 - CompletableFuture
异步编程越来越受到关注，因为它可以在等待资源（如I/O操作）时不阻塞主线程，从而提升系统的响应速度。Java 8 引入的CompletableFuture实现了更灵活的异步任务管理，允许开发者以流式API的方式组合多个异步任务。与传统的回调方式相比，CompletableFuture 提高了代码的可读性，并减少了“回调地狱”问题。
Java 8 引入了CompletableFuture，它提供了一个更加灵活的异步编程模型，支持串行和并行任务的组合，支持回调函数来处理任务结果。
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello";
}).thenApply(result -> result + " World");
future.thenAccept(System.out::println);
}
}
5. Java 9 - Flow API
在现代应用中，数据流的处理需求增加，比如实时流式数据处理和微服务架构下的消息传递。这些场景需要处理可持续产生的数据流，同时支持背压机制（backpressure），以避免在流速不匹配时产生的数据堆积。Java 9 引入的Flow API符合响应式流规范（Reactive Streams Specification），使Java能够适应流式数据的需求，提供更加稳健和可扩展的架构。
Java 9引入了Flow API，用于构建响应式流，以支持背压（backpressure）机制，增强了对流式数据处理的支持。
import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.Flow.*;
public class FlowExample {
public static void main(String[] args) throws InterruptedException {
SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
Subscriber<String> subscriber = new Subscriber<>() {
private Subscription subscription;
@Override
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
subscription.request(1);
}
@Override
public void onNext(String item) {
System.out.println("Received: " + item);
subscription.request(1);
}
@Override
public void onError(Throwable throwable) {
throwable.printStackTrace();
}
@Override
public void onComplete() {
System.out.println("Done");
}
};
publisher.subscribe(subscriber);
publisher.submit("Hello Reactive World!");
Thread.sleep(1000);
publisher.close();
}
}
6. Java 19 - Virtual Threads（预览）
随着微服务架构的普及，现代应用需要高并发处理，但传统的操作系统线程较重，创建和管理开销大，限制了高并发的实现。Java 19引入的虚拟线程提供了轻量级线程支持，使得每个I/O任务可以独占一个虚拟线程，无需担心线程资源耗尽问题。这种设计降低了阻塞对系统性能的影响，大大提升了并发处理能力，适合I/O密集型应用。
Java 19 引入了虚拟线程（Virtual Threads），提供轻量级线程支持，使得开发者可以创建大量线程而不会影响性能，适合I/O密集型应用。
public class VirtualThreadExample {
public static void main(String[] args) {
try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
executor.submit(() -> {
System.out.println("Virtual Thread Running");
return null;
});
}
}
}
总结
Java多线程支持的演进背后体现了一种逐步适应现代计算需求的发展趋势。每一阶段的改进都针对了特定的编程需求和硬件趋势，致力于让并发编程更高效、易用且适合更广泛的场景。
