Java Future 泛型声明最佳实践：消除编译器警告

// 假设 MyObject 实现了 Runnable 接口
List<Future<MyObject>> futures = new ArrayList<>();
// ...
for(String s : valuesToProcess) {
    // executor.submit(new MyObject(s)) 返回 Future<?> (因为 MyObject 是 Runnable)
    // 试图强制转换为 Future<MyObject> 导致 Unchecked cast 警告
    futures.add((Future<MyObject>) executor.submit(new MyObject(s)));
}

List<Future> futures = new ArrayList<>(); // Raw use of parameterized class 'Future'
// ...
for(String s : valuesToProcess) {
    futures.add(executor.submit(new MyObject(s)));
}

List<Future<?>这 futures = new ArrayList<>();

for(String s : valuesToProcess) {
    // executor.submit(new MyObject(s)) 返回 Future<?>
    // 直接添加到 List<Future<?>> 中是类型安全的，没有警告
    futures.add(executor.submit(new MyObject(s)));
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// 假设 MyObject 实现了 Runnable 接口，代表一个异步执行的任务
class MyObject implements Runnable {
    private static final Logger LOG = LoggerFactory.getLogger(MyObject.class);
    private String name;

    public MyObject(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            LOG.info("Processing: {}", name);
            // 模拟耗时操作
            Thread.sleep(100 + (long)(Math.random() * 500));
            LOG.info("Finished: {}", name);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断标志
            LOG.error("Task {} interrupted.", name, e);
        }
    }

    @Override
    public String toString() {
        return "MyObject{" + "name='" + name + '\'' + '}';
    }
}

public class FutureDeclarationGuide {
    private static final Logger LOG = LoggerFactory.getLogger(FutureDeclarationGuide.class);

    public void futuresTest() {
        List<String> valuesToProcess = List.of("A", "B", "C", "D", "E");
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        // 正确的声明方式：使用无界通配符 Future<?> 来收集 Future 对象
        // 因为 MyObject 实现了 Runnable，executor.submit(Runnable) 返回 Future<?>
        List<Future<?>> futures = new ArrayList<>();

        for (String s : valuesToProcess) {
            futures.add(executor.submit(new MyObject(s)));
        }

        LOG.info("Waiting for tasks to finish...");
        try {
            // 等待所有任务完成，或最多等待 10 分钟
            boolean termStatus = executor.awaitTermination(10, TimeUnit.MINUTES);

            if (termStatus) {
                LOG.info("All tasks completed successfully!");
                // 遍历 Future 列表，检查任务状态或获取结果
                for (Future<?> f : futures) {
                    try {
                        // 对于 Runnable 任务，f.get() 将返回 null。
                        // 对于 Callable 任务，f.get() 将返回实际结果。
                        // 调用 get() 会阻塞直到任务完成并获取结果（或抛出异常）
                        f.get(); 
                    } catch (ExecutionException e) {
                        // 捕获任务执行过程中抛出的异常
                        LOG.error("Task execution failed: {}", e.getMessage(), e);
                    }
                }
            } else {
                LOG.warn("Tasks timed out! Some tasks might still be running.");
                // 检查哪些任务未完成
                for (Future<?> f : futures) {
                    if (!f.isDone()) {
                        LOG.warn("Task still pending: {}", f);
                    }
                }
            }
        } catch (InterruptedException e) {
            // 当前线程在等待任务完成时被中断
            Thread.currentThread().interrupt(); // 重新设置中断标志
            LOG.error("Thread interrupted while waiting for tasks.", e);
            throw new RuntimeException("Interrupted during task execution.", e);
        } finally {
            // 务必关闭 ExecutorService 以释放资源
            // shutdown() 会等待已提交任务完成，不再接受新任务
            // shutdownNow() 会尝试停止所有正在执行的任务，并返回未启动的任务列表
            executor.shutdownNow(); 
            LOG.info("ExecutorService shut down.");
        }
    }

    public static void main(String[] args) {
        new FutureDeclarationGuide().futuresTest();
    }
}