Java Future声明与使用：避免类型警告的最佳实践

List<Future<MyObject>> futures = new ArrayList<>();
// ...
futures.add((Future<MyObject>) executor.submit(new MyObject(s)));

List<Future> futures = new ArrayList<>();
// ...
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;

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 object: {}", name);
            // 模拟耗时操作
            TimeUnit.MILLISECONDS.sleep(500);
            LOG.info("Finished processing object: {}", name);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.error("Task {} interrupted.", name, e);
        }
    }

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

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

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

        // 正确声明：任务不返回特定结果时使用 Future<?>
        List<Future<?> > futures = new ArrayList<>(); 

        for (String s : valuesToProcess) {
            // executor.submit(Runnable) 返回 Future<?>，直接添加，无警告
            futures.add(executor.submit(new MyObject(s))); 
        }

        LOG.info("Waiting for threads to finish...");
        try {
            boolean termStatus = executor.awaitTermination(11, TimeUnit.MINUTES); // 稍作延长以确保完成

            if (termStatus) {
                LOG.info("Success! All tasks completed.");
            } else {
                LOG.warn("Timed Out! Not all tasks finished.");
                for (Future<?> f : futures) {
                    if (!f.isDone()) {
                        LOG.warn("Failed to process task: {}", f);
                    }
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.error("Main thread interrupted while waiting for termination.", e);
            throw new RuntimeException("Main thread interrupted", e);
        } finally {
            executor.shutdownNow(); // 确保线程池最终关闭
        }
    }

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

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

// MyCallableObject 实现 Callable<String>，返回一个String结果
class MyCallableObject implements Callable<String> {
    private static final Logger LOG = LoggerFactory.getLogger(MyCallableObject.class);
    private String input;

    public MyCallableObject(String input) {
        this.input = input;
    }

    @Override
    public String call() throws Exception {
        LOG.info("Processing callable object: {}", input);
        TimeUnit.MILLISECONDS.sleep(700); // 模拟耗时操作
        String result = "Processed_" + input;
        LOG.info("Finished processing callable object: {}, Result: {}", input, result);
        return result; // 返回一个String结果
    }

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

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

    public void callableFuturesTest() {
        List<String> valuesToProcess = List.of("X", "Y", "Z");
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        // 正确声明：任务返回String结果时使用 Future<String>
        List<Future<String>> futures = new ArrayList<>(); 

        for (String s : valuesToProcess) {
            // executor.submit(Callable<String>) 返回 Future<String>，直接添加，无警告
            futures.add(executor.submit(new MyCallableObject(s))); 
        }

        LOG.info("Waiting for callable tasks to finish and retrieving results...");
        for (Future<String> future : futures) {
            try {
                String result = future.get(); // 获取任务的String结果
                LOG.info("Retrieved result: {}", result);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                LOG.error("Task interrupted while getting result.", e);
            } catch (ExecutionException e) {
                LOG.error("Task execution failed: {}", e.getCause().getMessage(), e);
            }
        }

        executor.shutdown(); // 启动优雅关闭
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                LOG.warn("Executor did not terminate in time, forcing shutdown.");
                executor.shutdownNow(); // 强制关闭
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.error("Main thread interrupted during shutdown.", e);
            executor.shutdownNow();
        }
        LOG.info("All callable tasks processed and results retrieved.");
    }

    public static void main(String[] args) {
        new FutureCallableExample().callableFuturesTest();
    }
}