如何在Java中正确声明和管理Future对象以避免警告

// 假设 MyObject 实现了 Runnable 接口
// 或者 MyObject 实现了 Callable 但其泛型参数不是 MyObject
Future<MyObject> future = (Future<MyObject>) executor.submit(new MyObject("data"));
// 警告: Unchecked cast: 'java.util.concurrent.Future<capture<?>>' to 'java.util.concurrent.Future<model.MyObject>'

List<Future> futures = new ArrayList<>(); // 警告: Raw use of parameterized class 'Future'
Future future = executor.submit(new MyObject("data")); // 警告: Raw use of parameterized class 'Future'

List<Future<?>> futures = new ArrayList<>(); // 无警告，表示Future的泛型类型未知
Future<?> future = executor.submit(new MyObject("data")); // 无警告

List<Future<String>> futures = new ArrayList<>(); // 无警告
Future<String> future = executor.submit(new MyCallableTask("data")); // 无警告

import java.util.concurrent.Callable; // 仅为后续示例引入，此处不使用
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// 假设 MyObject 实现了 Runnable 接口
class MyRunnableTask implements Runnable {
    private String id;
    private static final Logger LOG = LoggerFactory.getLogger(MyRunnableTask.class);

    public MyRunnableTask(String id) {
        this.id = id;
    }

    @Override
    public void run() {
        LOG.info("Processing Runnable task: {}", id);
        try {
            // 模拟耗时操作
            TimeUnit.MILLISECONDS.sleep(100 + (long) (Math.random() * 200));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.warn("Runnable task {} interrupted.", id);
        }
        LOG.info("Finished Runnable task: {}", id);
    }

    @Override
    public String toString() {
        return "MyRunnableTask(id=" + id + ")";
    }
}

public class FutureDeclarationTutorial {

    private static final Logger LOG = LoggerFactory.getLogger(FutureDeclarationTutorial.class);

    public void processRunnableTasks() {
        List<String> valuesToProcess = List.of("A", "B", "C", "D", "E");
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        // 核心：使用 List<Future<?>> 声明，避免警告
        List<Future<?>> futures = new ArrayList<>();

        for (String s : valuesToProcess) {
            futures.add(executor.submit(new MyRunnableTask(s))); // 无警告
        }

        LOG.info("Waiting for Runnable tasks to finish...");

        // 优雅地关闭 ExecutorService
        executor.shutdown();
        try {
            boolean termStatus = executor.awaitTermination(10, TimeUnit.MINUTES);

            if (termStatus) {
                LOG.info("All Runnable tasks finished successfully!");
            } else {
                LOG.warn("Runnable tasks timed out!");
                for (Future<?> f : futures) {
                    if (!f.isDone()) {
                        LOG.warn("Failed to process {}: Task not done.", f);
                    }
                }
            }
        } catch (InterruptedException e) {
            LOG.error("Main thread interrupted while waiting for tasks.", e);
            Thread.currentThread().interrupt();
        } finally {
            // 确保即使超时或中断也能尝试取消未完成的任务
            if (!executor.isTerminated()) {
                LOG.warn("Forcing shutdown of remaining tasks.");
                executor.shutdownNow();
            }
        }

        // 对于 Runnable 任务，Future.get() 返回 null，通常不需要获取
        // 但如果需要检查任务是否抛出异常，可以尝试调用 get()
        LOG.info("Checking Runnable task results (if any exceptions occurred)...");
        for (Future<?> f : futures) {
            try {
                // 调用 get() 会阻塞直到任务完成，并抛出 ExecutionException 如果任务抛出异常
                f.get();
            } catch (InterruptedException e) {
                LOG.error("Interrupted while getting result for {}.", f, e);
                Thread.currentThread().interrupt();
            } catch (ExecutionException e) {
                LOG.error("Runnable task {} threw an exception: {}", f, e.getCause().getMessage());
            }
        }
    }
    // ... 其他方法 ...
}

// ... (MyRunnableTask 和 FutureDeclarationTutorial 的导入和类定义) ...

class MyCallableTask implements Callable<String> {
    private String data;
    private static final Logger LOG = LoggerFactory.getLogger(MyCallableTask.class);

    public MyCallableTask(String data) {
        this.data = data;
    }

    @Override
    public String call() throws Exception {
        LOG.info("Processing Callable task for data: {}", data);
        try {
            // 模拟耗时操作
            TimeUnit.MILLISECONDS.sleep(50 + (long) (Math.random() * 150));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.warn("Callable task for data {} interrupted.", data