Java高频面试之并发编程-05

news2025/4/23 8:24:30

hello啊，各位观众姥爷们！！！本baby今天来报道了！哈哈哈哈哈嗝🐶

面试官：线程有哪些调度方法？

在Java中，线程的调用方法主要包括以下几种方式，每种方式适用于不同的场景和需求：

1. 继承 `Thread` 类

通过继承 Thread 类并重写 run() 方法，直接调用线程的 start() 方法启动线程。

实现步骤：

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

// 调用方式
public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程，执行run()
    }
}

特点：

优点：简单直接。
缺点：Java是单继承，继承 Thread 后无法继承其他类。
适用场景：简单任务，无需共享资源。

2. 实现 `Runnable` 接口

实现 Runnable 接口，将任务逻辑写入 run() 方法，然后将实例传递给 Thread 对象。

实现步骤：

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

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

特点：

优点：避免单继承限制，任务与线程解耦，适合资源共享（如多个线程执行同一任务）。
适用场景：多线程共享同一任务逻辑。

3. 实现 `Callable` 接口 + `Future`

通过 Callable 定义带返回值的任务，结合 ExecutorService 提交任务，并通过 Future 获取结果。

实现步骤：

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Result from Callable";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get()); // 阻塞获取结果
        executor.shutdown();
    }
}

特点：

优点：支持返回值，可抛出异常。
适用场景：需要异步结果的任务（如计算密集型操作）。

4. 线程池（`Executor` 框架）

通过线程池管理线程生命周期，避免频繁创建/销毁线程的开销。

实现步骤：

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

public class Main {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交Runnable任务
        executor.execute(() -> {
            System.out.println("Task executed by thread pool");
        });

        executor.shutdown(); // 关闭线程池
    }
}

线程池类型：

newFixedThreadPool：固定线程数，适用于负载稳定的场景。
newCachedThreadPool：线程数自动扩展，适合短时异步任务。
newScheduledThreadPool：支持定时或周期性任务。
newSingleThreadExecutor：单线程顺序执行任务。

特点：

优点：资源复用、控制并发数、提供任务队列。
适用场景：高并发、资源受限的系统。

5. 匿名内部类/Lambda表达式

简化线程创建的语法，适用于快速实现简单任务。

实现方式：

public class Main {
    public static void main(String[] args) {
        // 匿名内部类（Runnable）
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Runnable");
            }
        }).start();

        // Lambda表达式（Java 8+）
        new Thread(() -> System.out.println("Lambda Runnable")).start();
    }
}

特点：

优点：代码简洁。
适用场景：快速测试或简单任务。

6. 定时任务（`ScheduledExecutorService`）

用于执行定时或周期性任务。

实现步骤：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 延迟1秒后执行
        scheduler.schedule(() -> System.out.println("Delayed task"), 1, TimeUnit.SECONDS);

        // 周期性任务（首次延迟2秒，之后每3秒执行一次）
        scheduler.scheduleAtFixedRate(() -> System.out.println("Periodic task"), 2, 3, TimeUnit.SECONDS);
    }
}

7. 异步编程（`CompletableFuture`，Java 8+）

通过链式调用处理异步任务，支持回调和非阻塞操作。

实现步骤：

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> "Async Result")
            .thenAccept(result -> System.out.println(result))
            .join(); // 等待异步任务完成
    }
}

特点：

优点：支持链式调用、异常处理、任务组合。
适用场景：复杂的异步编程需求（如多个异步任务依赖）。

总结与选型建议

方法	核心优势	典型场景
继承 `Thread`	简单直接	快速测试或简单任务
实现 `Runnable`	解耦任务与线程，支持资源共享	多线程共享任务逻辑
实现 `Callable`	支持返回值和异常	需要异步结果的计算任务
线程池	资源复用，高效管理线程	高并发、资源受限的系统
`CompletableFuture`	异步编程，链式调用	复杂异步任务编排