Java线程创建与并发管理-CSDN博客

本文链接：https://blog.csdn.net/abc666_666/article/details/147629680

在Java编程中，线程是实现并发的基础，允许程序同时执行多个任务。这对于需要处理多个用户请求、多个连接或在后台执行任务而不阻塞主线程的应用至关重要。例如，Web服务器可能需要同时处理数百个用户请求，而桌面应用可能需要在加载文件时保持用户界面响应。本文将详细介绍Java中线程的创建方法，从传统方式到现代推荐方法，并探讨确保线程安全和高效并发的最佳实践。

1. 基本线程创建

在Java早期，线程通常通过以下两种方式创建：扩展Thread类或实现Runnable接口。尽管这些方法简单直观，但由于性能开销和缺乏灵活性，它们在现代Java编程中已不推荐使用。

1.1 扩展Thread类

通过继承java.lang.Thread并重写run()方法，可以创建一个线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("运行在独立线程中");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 注意：调用start()，而不是run()！
    }
}

这种方法简单，但限制了类的继承能力，因为Java只允许单继承。

1.2 实现Runnable接口

实现Runnable接口是更灵活的方式，因为它允许类继承其他类。Runnable接口只有一个run()方法。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("运行在独立线程中");
    }
}

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

从Java 8开始，可以使用Lambda表达式简化Runnable的实现：

Runnable r = () -> System.out.println("运行在独立线程中");
Thread thread = new Thread(r);
thread.start();

1.3 传统方法的局限性

直接创建Thread对象存在以下问题：

性能开销：每次创建和销毁线程都会消耗大量资源。
资源管理困难：手动管理多个线程可能导致线程饥饿或死锁。
缺乏灵活性：无法轻松处理返回值的任务。

因此，现代Java推荐使用ExecutorService和线程池来管理线程。

2. 使用ExecutorService进行线程管理

ExecutorService是java.util.concurrent包中的接口，通过线程池管理线程。线程池是一组预先创建的线程，可以重复使用以执行任务，从而减少线程创建和销毁的开销。

2.1 创建ExecutorService

虽然Executors类提供了便捷的工厂方法（如newFixedThreadPool），但更推荐直接使用ThreadPoolExecutor构造函数，以便精确控制线程池参数，避免潜在的资源耗尽问题。

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.LinkedBlockingQueue;

ThreadPoolExecutor pool = new ThreadPoolExecutor(
    5, // 核心线程数
    10, // 最大线程数
    60L, // 空闲线程存活时间
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<Runnable>() // 任务队列
);

2.2 提交任务

ExecutorService支持提交Runnable和Callable任务。Runnable不返回值，而Callable可以返回结果。

提交Runnable任务：

pool.execute(() -> System.out.println("执行Runnable任务"));

提交Callable任务：

Future<String> future = pool.submit(() -> {
    Thread.sleep(1000);
    return "任务完成";
});
String result = future.get(); // 阻塞直到任务完成

2.3 优雅关闭ExecutorService

使用完ExecutorService后，必须关闭以释放资源。推荐使用优雅关闭方式：

pool.shutdown();
try {
    if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
        pool.shutdownNow(); // 强制关闭
    }
} catch (InterruptedException ex) {
    pool.shutdownNow();
    Thread.currentThread().interrupt();
}

2.4 使用ExecutorService的优势

线程复用：减少线程创建和销毁的开销。
资源控制：通过配置线程池大小和队列，优化资源使用。
支持Callable：允许任务返回结果，适合需要结果的场景。

3. 并发编程最佳实践

并发编程需要特别注意线程安全，以避免竞态条件、死锁等问题。以下是一些关键的最佳实践：

3.1 使用不可变对象

不可变对象在创建后无法修改，因此天生线程安全。通过使用final字段和不提供setter方法实现。

public final class ImmutableClass {
    private final int value;

    public ImmutableClass(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

3.2 使用并发集合

对于共享数据结构，使用java.util.concurrent包中的并发集合，如ConcurrentHashMap或CopyOnWriteArrayList，以提高性能和线程安全。

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

3.3 使用原子变量

对于简单的共享变量，使用java.util.concurrent.atomic包中的原子类（如AtomicInteger）进行无锁线程安全操作。

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger counter = new AtomicInteger(0);
int newValue = counter.incrementAndGet();

3.4 同步共享可变状态

如果必须共享可变状态，使用synchronized关键字或锁机制确保线程安全。

public class SharedResource {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

3.5 避免使用wait()/notify()

低级的wait()/notify()机制复杂且容易出错。推荐使用java.util.concurrent中的高级工具，如BlockingQueue或Condition。

4. 理解Future和CompletableFuture

4.1 Future

Future表示异步计算的结果，提供检查任务状态、获取结果或取消任务的方法。

isDone()：检查任务是否完成。
get()：等待任务完成并返回结果。
get(long timeout, TimeUnit unit)：带超时的等待。
cancel(boolean mayInterruptIfRunning)：尝试取消任务。

示例：

Callable<Double> computeTotal = () -> 2.0 + 2.0;
Future<Double> future = pool.submit(computeTotal);
while (!future.isDone()) {
    Thread.sleep(100);
}
double value = future.get();

4.2 CompletableFuture

CompletableFuture是Future的增强版，支持任务链、异步执行和异常处理。

创建CompletableFuture

可以通过手动完成或异步提供结果创建CompletableFuture。

CompletableFuture<String> cf = new CompletableFuture<>();
// 稍后完成
cf.complete("结果");

链式操作

CompletableFuture支持链式操作，允许在任务完成后自动执行后续操作。

CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")
    .thenApply(s -> s + "!");
cf.thenAccept(System.out::println);

supplyAsync异步提供初始值，thenApply转换结果，thenAccept处理最终结果。

异常处理

CompletableFuture支持异常处理，确保程序健壮性。

CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("错误");
    return "成功";
}).exceptionally(ex -> "处理异常: " + ex.getMessage())
  .thenAccept(System.out::println);

5. 结论

本文介绍了Java中线程创建的多种方法，从传统的Thread和Runnable到现代的ExecutorService和CompletableFuture。通过使用线程池和高级并发工具，开发者可以编写高效、可扩展的并发程序。同时，遵循线程安全最佳实践（如使用不可变对象和并发集合）可以显著降低并发编程的复杂性。希望本文能帮助您在Java并发编程中游刃有余！