正文

Java实现同时发三次请求，可以这样操作：

/0 浏览量
0603

在Java中，实现同时发送三次请求有多种方式，以下是一些常见的方法和示例：

1. 使用 ExecutorService 和 Callable

这种方式利用了Java的并发工具，可以同时执行多个任务。

import java.util.concurrent.*;

public class MultiThreadedRequests {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future<String> future1 = executor.submit(new Callable<String>() {
            public String call() throws Exception {
                // 发送第一个请求
                return "Response 1";
            }
        });

        Future<String> future2 = executor.submit(new Callable<String>() {
            public String call() throws Exception {
                // 发送第二个请求
                return "Response 2";
            }
        });

        Future<String> future3 = executor.submit(new Callable<String>() {
            public String call() throws Exception {
                // 发送第三个请求
                return "Response 3";
            }
        });

        // 获取结果
        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());

        executor.shutdown();
    }
}

2. 使用 CompletableFuture

CompletableFuture 提供了一种更加简洁的方式来处理异步操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 发送第一个请求
            return "Response 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 发送第二个请求
            return "Response 2";
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            // 发送第三个请求
            return "Response 3";
        });

        // 等待所有请求完成
        CompletableFuture.allOf(future1, future2, future3).join();

        // 打印结果
        System.out.println(future1.join());
        System.out.println(future2.join());
        System.out.println(future3.join());
    }
}

3. 使用 HttpClient

如果你需要发送HTTP请求，可以使用 HttpClient 来实现。

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://example.com"))
                .build();

        CompletableFuture<HttpResponse<String>> future1 = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body);

        CompletableFuture<HttpResponse<String>> future2 = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body);

        CompletableFuture<HttpResponse<String>> future3 = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body);

        // 等待所有请求完成
        CompletableFuture.allOf(future1, future2, future3).join();

        // 打印结果
        System.out.println(future1.join());
        System.out.println(future2.join());
        System.out.println(future3.join());
    }
}

以上三种方法都可以实现Java中同时发送三次请求。你可以根据实际情况选择最适合你的方法。

-- 展开阅读全文 --