Android中OkHttpClient同步等待的正确方法

理解Android网络请求与主线程限制

在Android平台上，所有耗时的操作（如网络请求、文件I/O等）都禁止在主线程（UI线程）上执行，以避免造成ANR（Application Not Responding）错误，从而提升用户体验。OkHttpClient默认提供了两种执行网络请求的方式：

1. enqueue(Callback)：这是一个异步方法，它会将请求放入后台线程池执行，并立即返回。请求结果通过回调接口onResponse或onFailure异步通知。
2. execute()：这是一个同步方法，它会阻塞当前线程直到请求完成并返回响应。

当我们需要在一个子Activity中发起网络请求，并期望在请求完成后才将数据返回给父Activity时，直接使用enqueue()会导致子Activity在网络请求完成前就返回，因为enqueue()是非阻塞的。而尝试在主线程中调用execute()则会立即触发android.os.NetworkOnMainThreadException。

使用CountDownLatch同步网络请求

为了解决上述问题，我们可以在一个后台线程中发起异步网络请求，并利用java.util.concurrent.CountDownLatch机制来同步等待请求的完成。CountDownLatch是一个同步辅助类，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

CountDownLatch工作原理：

• 初始化时设置一个计数器（通常为1，表示等待一个事件）。
• 当需要等待的线程调用await()方法时，该线程会被阻塞，直到计数器归零。
• 当被等待的事件发生时，执行线程调用countDown()方法，使计数器减1。
• 当计数器减到0时，所有调用await()的线程都会被释放。

实现步骤：

1. 创建CountDownLatch实例： 在发起网络请求的逻辑中，创建一个CountDownLatch实例，并将其计数器初始化为1。
2. 发起异步网络请求： 使用OkHttpClient的enqueue()方法发起网络请求。
3. 在回调中调用countDown()： 无论网络请求成功（onResponse）还是失败（onFailure），都在回调方法的末尾调用latch.countDown()，通知等待线程请求已完成。
4. 调用await()等待： 在主线程（或其他需要等待的线程）中调用latch.await()方法。为了防止无限期等待，建议设置一个合理的超时时间。

示例代码：

假设我们有一个SecondaryActivity，它需要从REST API获取数据，并在数据获取后才关闭并返回结果。

import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class SecondaryActivity extends AppCompatActivity {

    private String apiResponseData = null; // 用于存储网络请求结果

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_secondary); // 假设有一个布局

        // 在后台线程中执行网络请求和等待逻辑
        new Thread(new Runnable() {
            @Override
            public void run() {
                performNetworkRequestAndWait();
                // 网络请求完成后，可以在这里处理数据并关闭Activity
                // 注意：UI操作仍需回到主线程
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        if (apiResponseData != null) {
                            // 处理获取到的数据，例如更新UI或设置结果
                            System.out.println("Received data: " + apiResponseData);
                            // 示例：设置结果并关闭Activity
                            // Intent resultIntent = new Intent();
                            // resultIntent.putExtra("data", apiResponseData);
                            // setResult(RESULT_OK, resultIntent);
                            // finish();
                        } else {
                            System.out.println("Failed to retrieve data.");
                            // setResult(RESULT_CANCELED);
                            // finish();
                        }
                    }
                });
            }
        }).start();
    }

    private void performNetworkRequestAndWait() {
        // 创建一个CountDownLatch，计数器为1
        CountDownLatch latch = new CountDownLatch(1);

        OkHttpClient client = new OkHttpClient();
        // 假设someRequest是一个JSON字符串
        String someRequest = "{ \"key\": \"value\" }";
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), someRequest);
        String myURL = "https://api.example.com/data"; // 替换为你的API地址
        Request request = new Request.Builder().url(myURL).post(body).build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {
                System.err.println("Network request failed: " + e.getMessage());
                apiResponseData = null; // 请求失败，数据为空
                latch.countDown(); // 无论成功失败，都要释放latch
            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                if (response.isSuccessful() && response.body() != null) {
                    apiResponseData = response.body().string();
                    System.out.println("Network response: " + apiResponseData);
                } else {
                    System.err.println("Network request unsuccessful: " + response.code());
                    apiResponseData = null;
                }
                latch.countDown(); // 无论成功失败，都要释放latch
            }
        });

        try {
            // 等待网络请求完成，最多等待10秒
            // await()方法会阻塞当前线程，直到latch.countDown()被调用或超时
            boolean completed = latch.await(10, TimeUnit.SECONDS);
            if (!completed) {
                System.err.println("Network request timed out.");
                apiResponseData = null; // 超时，数据为空
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断状态
            System.err.println("Waiting for network request was interrupted: " + e.getMessage());
            apiResponseData = null; // 中断，数据为空
        }
        // 在此处，apiResponseData变量将包含网络请求的结果（如果成功且未超时）
        // 或者为null（如果失败、超时或中断）
    }
}

代码解析：

1. CountDownLatch latch = new CountDownLatch(1);：初始化一个计数器为1的CountDownLatch。
2. client.newCall(request).enqueue(...)：发起异步网络请求。
3. 在onFailure和onResponse回调中，无论请求结果如何，都调用latch.countDown()。这会将计数器减到0，从而释放所有在latch.await()上等待的线程。
4. latch.await(10, TimeUnit.SECONDS);：调用此方法的线程（在本例中是新创建的后台线程）将被阻塞，直到latch.countDown()被调用（即网络请求完成）或等待时间超过10秒。
5. apiResponseData：在await()之后，apiResponseData变量将包含网络请求的结果，可以在此处对其进行处理。

注意事项与最佳实践

• 线程管理： 务必在后台线程中执行CountDownLatch的await()方法以及OkHttpClient的enqueue()方法。在主线程中调用await()仍会导致ANR。本示例中，我们通过new Thread().start()创建了一个新的后台线程来执行整个同步等待逻辑。
• UI更新： 即使CountDownLatch的await()方法在后台线程中完成，任何需要更新UI的操作仍然必须回到主线程执行，例如通过Activity.runOnUiThread()或Handler。
• 超时处理： latch.await(timeout, unit)是强制性的。如果网络请求长时间没有响应，没有超时机制会导致后台线程无限期阻塞。合理设置超时时间可以防止资源泄露和潜在的ANR。
• 错误处理： 在onFailure回调中也调用latch.countDown()至关重要，以确保即使请求失败，等待的线程也能被释放。同时，处理InterruptedException也是良好实践。
• 数据传递： 在await()之后，获取到的数据可以存储在Activity的成员变量中，供后续处理。如果需要将数据传递回父Activity，可以使用setResult()和finish()。
• 替代方案： 对于更复杂的异步场景，例如多个并行请求、请求链等，可以考虑使用更高级的并发框架，如Kotlin Coroutines（推荐）、RxJava或AsyncTask（已废弃，不推荐新项目使用）。CountDownLatch适用于简单的“等待一个或一组特定事件完成”的同步场景。

总结

CountDownLatch提供了一种简单而有效的机制，用于在Android后台线程中同步等待OkHttpClient异步网络请求的结果。通过在请求回调中释放锁，并在另一个线程中阻塞等待，我们可以确保依赖网络数据的逻辑在数据可用后才执行，同时避免了NetworkOnMainThreadException和ANR。正确地结合线程管理、超时和错误处理，可以构建出健壮且响应迅速的Android应用。