回答

使用 Java 线程池实现并发请求接口，可以有效地管理线程资源，提高系统的吞吐量和响应速度。以下是实现步骤和代码示例：

1. 创建线程池

可以使用 java.util.concurrent.Executors 类提供的工厂方法创建不同类型的线程池，例如固定大小的线程池、缓存线程池等。

// 创建固定大小为 10 的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);

// 创建缓存线程池，最大线程数为 Integer.MAX_VALUE
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

2. 定义请求任务

将每个请求封装成一个 Runnable 或 Callable 任务，在任务的 run() 或 call() 方法中实现具体的请求逻辑。

class RequestTask implements Callable<String> {
    private String url;

    public RequestTask(String url) {
        this.url = url;
    }

    @Override
    public String call() throws Exception {
        // 模拟发送 HTTP 请求并获取响应
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("GET");
        int responseCode = con.getResponseCode();
        return "Response Code : " + responseCode;
    }
}

3. 提交请求任务

调用线程池的 execute() 或 submit() 方法将请求任务提交到线程池。execute() 方法用于 Runnable 任务，submit() 方法用于 Callable 任务并返回 Future 对象，可以通过 Future 对象获取任务执行结果。

// 提交请求任务
List<Future<String>> futures = new ArrayList<>();
for (String url : urls) {
    RequestTask task = new RequestTask(url);
    futures.add(threadPool.submit(task));
}

4. 处理请求结果

遍历 Future 对象列表，调用 get() 方法获取每个任务的执行结果。get() 方法会阻塞直到任务执行完成。

// 处理请求结果
for (Future<String> future : futures) {
    try {
        System.out.println(future.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

5. 关闭线程池

任务执行完毕后，调用线程池的 shutdown() 或 shutdownNow() 方法关闭线程池。

// 关闭线程池
threadPool.shutdown();

完整示例代码：

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ConcurrentRequestExample {

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

        // 请求 URL 列表
        List<String> urls = new ArrayList<>();
        urls.add("https://www.example.com/");
        urls.add("https://www.google.com/");
        urls.add("https://www.baidu.com/");


        // 提交请求任务
        List<Future<String>> futures = new ArrayList<>();
        for (String url : urls) {
            RequestTask task = new RequestTask(url);
            futures.add(threadPool.submit(task));
        }

        // 处理请求结果
        for (Future<String> future : futures) {
            try {
                System.out.println(future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

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

    static class RequestTask implements Callable<String> {
        private String url;

        public RequestTask(String url) {
            this.url = url;
        }

        @Override
        public String call() throws Exception {
            // 模拟发送 HTTP 请求并获取响应
            URL obj = new URL(url);
            HttpURLConnection con = (HttpURLConnection) obj
.openConnection();
            con.setRequestMethod("GET");
            int responseCode = con.getResponseCode();
            return "Response Code for " + url + ": " + responseCode;
        }
    }
}

需要注意的是：

线程池的大小应该根据实际的硬件资源和请求量进行调整。在请求任务中应该妥善处理异常，避免线程池中的线程因为异常而终止。可以使用 Future 对象的 get(long timeout, TimeUnit unit) 方法设置超时时间，避免任务阻塞时间过长。