Java并发编程：正确声明Future以避免泛型警告

List<Future> futures = new ArrayList<>(); // 警告：Raw use of parameterized class 'Future'

List<Future<MyObject>> futures = new ArrayList<>();
// ...
futures.add((Future<MyObject>) executor.submit(new MyObject("data"))); // 警告：Unchecked cast

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

// 假设MyObject是一个实现了Runnable的类，或者是一个Callable<Void>的类
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);
            // 模拟耗时操作
            TimeUnit.MILLISECONDS.sleep(500 + (long)(Math.random() * 500));
            LOG.info("Finished processing: {}", name);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.warn("Task {} interrupted.", name, e);
        }
    }
}

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<?> 声明，消除警告
        List<Future<?>> futures = new ArrayList<>(); 

        for (String s : valuesToProcess) {
            // MyObject 实现了 Runnable，submit 返回 Future<?>
            futures.add(executor.submit(new MyObject(s))); 
        }

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

            if (termStatus) {
                LOG.info("All tasks completed successfully.");
            } else {
                LOG.warn("Tasks timed out!");
                for (Future<?> f : futures) {
                    if (!f.isDone()) {
                        LOG.warn("Failed to process task: {}", f);
                    }
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.error("Waiting for tasks was interrupted.", e);
            throw new RuntimeException("Future test interrupted", e);
        } finally {
            // 务必关闭ExecutorService以释放资源
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    executor.shutdownNow(); // 强制关闭
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }

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

import java.util.concurrent.Callable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

    @Override
    public String call() throws Exception {
        LOG.info("Callable processing: {}", input);
        // 模拟耗时操作并返回结果
        TimeUnit.MILLISECONDS.sleep(200 + (long)(Math.random() * 300));
        String result = "Processed-" + input;
        LOG.info("Callable finished: {}", result);
        return result;
    }
}

public class FutureWithSpecificType {

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

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

        // 声明 List<Future<String>> 因为 MyCallable 返回 String
        List<Future<String>> futures = new ArrayList<>(); 

        for (String input : inputs) {
            futures.add(executor.submit(new MyCallable(input))); // 无需强制转换，无警告
        }

        LOG.info("Waiting for callable tasks to finish and collecting results...");
        List<String> results = new ArrayList<>();
        for (Future<String> future : futures) {
            try {
                String result = future.get(); // 直接获取 String 类型结果
                results.add(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());
            }
        }

        LOG.info("All callable tasks completed. Results: {}", results);
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        new FutureWithSpecificType().callableTest();
    }
}