Android：使用Retrofit定时轮询双API的高效方案对比

Alright, let's dive into how to handle repeated Retrofit API calls—one every 10 seconds and another every 3 seconds—using Threads, Kotlin Coroutines, and RxJava. I'll break down each approach's usage, share code examples, and compare their efficiency so you can pick the right tool for the job.

1. Thread-Based Implementation #

Threads are the most low-level way to run background tasks, but they come with manual overhead. Here's how to use them for your repeated API calls:

Usage Notes #

• You'll need to spawn separate threads for each interval, since threads are blocking when using Thread.sleep().
• Always handle thread interruption to avoid memory leaks (e.g., when your Activity/ViewModel is destroyed).
• Retrofit's synchronous calls must run off the main thread, so wrap them in a Thread (or use runBlocking if you're calling suspend functions).

Code Example #

// Assume we have a Retrofit service interface
interface ApiService {
    @GET("data/10s-interval")
    suspend fun fetch10sData(): Response<DataModel1>

    @GET("data/3s-interval")
    suspend fun fetch3sData(): Response<DataModel2>
}

val apiService = retrofit.create(ApiService::class.java)

// Thread for 3-second interval calls
val threeSecondThread = Thread {
    while (!Thread.currentThread().isInterrupted) {
        try {
            // Use runBlocking to call suspend Retrofit functions
            val response = runBlocking { apiService.fetch3sData() }
            // Switch back to main thread for UI updates
            runOnUiThread { /* Update UI with response data */ }
            Thread.sleep(3000)
        } catch (e: InterruptedException) {
            // Properly handle interruption to exit the loop
            Thread.currentThread().interrupt()
        } catch (e: Exception) {
            // Log network errors
            e.printStackTrace()
            // Retry after delay even on failure
            Thread.sleep(3000)
        }
    }
}

// Thread for 10-second interval calls
val tenSecondThread = Thread {
    while (!Thread.currentThread().isInterrupted) {
        try {
            val response = runBlocking { apiService.fetch10sData() }
            runOnUiThread { /* Update UI with response data */ }
            Thread.sleep(10000)
        } catch (e: InterruptedException) {
            Thread.currentThread().interrupt()
        } catch (e: Exception) {
            e.printStackTrace()
            Thread.sleep(10000)
        }
    }
}

// Start the threads
threeSecondThread.start()
tenSecondThread.start()

// To cancel (e.g., in Activity onDestroy)
// threeSecondThread.interrupt()
// tenSecondThread.interrupt()

Efficiency & Tradeoffs #

• Lowest efficiency: Each thread is a heavyweight OS resource. Even when sleeping, threads consume memory and require expensive kernel-level context switches if you have many tasks.
• High maintenance: Manual thread management is error-prone—forgetting to interrupt threads leads to memory leaks.
• Only for simple use cases: Avoid this approach in production apps unless you have a very trivial scenario.

2. Kotlin Coroutines Implementation #

Coroutines are Kotlin's lightweight alternative to threads, designed for efficient background task management. They're the preferred approach for modern Android/Kotlin apps.

Usage Notes #

• Use a coroutine scope (like viewModelScope or lifecycleScope) to auto-manage lifecycle—coroutines are canceled automatically when the scope is destroyed.
• delay() is non-blocking: it suspends the coroutine instead of blocking the thread, letting the thread handle other tasks while waiting.
• Use Dispatchers.IO for network calls and Dispatchers.Main for UI updates.

Code Example #

class DataViewModel : ViewModel() {
    private val apiService = retrofit.create(ApiService::class.java)

    init {
        startRepeatedCalls()
    }

    private fun startRepeatedCalls() {
        // 3-second interval call
        viewModelScope.launch(Dispatchers.IO) {
            while (isActive) { // Auto-canceled when viewModelScope is destroyed
                try {
                    val response = apiService.fetch3sData()
                    // Switch to main thread for UI updates
                    withContext(Dispatchers.Main) { /* Update UI */ }
                    delay(3000) // Non-blocking delay
                } catch (e: Exception) {
                    e.printStackTrace()
                    delay(3000) // Retry after failure
                }
            }
        }

        // 10-second interval call
        viewModelScope.launch(Dispatchers.IO) {
            while (isActive) {
                try {
                    val response = apiService.fetch10sData()
                    withContext(Dispatchers.Main) { /* Update UI */ }
                    delay(10000)
                } catch (e: Exception) {
                    e.printStackTrace()
                    delay(10000)
                }
            }
        }
    }
}

Efficiency & Tradeoffs #

• Highest efficiency: Coroutines are lightweight (thousands can run on a single thread). Suspending/resuming uses user-level context switches, which are far cheaper than kernel-level thread switches.
• Low maintenance: Scopes handle auto-cancellation, eliminating memory leaks. Code is concise and readable.
• Modern Kotlin standard: This is the go-to approach for new Kotlin projects, especially Android apps.

3. RxJava Implementation #

RxJava is a reactive programming library that uses observable streams to handle asynchronous tasks. It's popular in legacy Android projects or apps using reactive architectures.

Usage Notes #

• Use Observable.interval() to create streams that emit events at your desired intervals.
• Use subscribeOn() to run network calls on an IO thread, and observeOn() to switch back to the main thread for UI updates.
• Manage subscriptions with CompositeDisposable to avoid memory leaks.

Code Example #

First, add Retrofit's RxJava adapter dependency, then define your service:

interface ApiService {
    @GET("data/10s-interval")
    fun fetch10sData(): Observable<Response<DataModel1>>

    @GET("data/3s-interval")
    fun fetch3sData(): Observable<Response<DataModel2>>
}

class DataPresenter {
    private val apiService = retrofit.create(ApiService::class.java)
    private val compositeDisposable = CompositeDisposable()

    fun startRepeatedCalls() {
        // 3-second interval stream
        val threeSecondStream = Observable.interval(0, 3, TimeUnit.SECONDS)
            .flatMap { apiService.fetch3sData() }
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { response -> /* Handle success */ },
                { error -> /* Handle failure */ }
            )

        // 10-second interval stream
        val tenSecondStream = Observable.interval(0, 10, TimeUnit.SECONDS)
            .flatMap { apiService.fetch10sData() }
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { response -> /* Handle success */ },
                { error -> /* Handle failure */ }
            )

        // Add subscriptions to composite for lifecycle management
        compositeDisposable.add(threeSecondStream)
        compositeDisposable.add(tenSecondStream)
    }

    // Call this when the presenter is destroyed
    fun onDestroy() {
        compositeDisposable.dispose()
    }
}

Efficiency & Tradeoffs #

• Medium efficiency: RxJava uses thread pools under the hood, so it's more efficient than raw Threads but less efficient than coroutines. Thread pool threads are still heavyweight compared to coroutines.
• Steeper learning curve: Reactive programming concepts and operators can be overwhelming for beginners.
• Good for legacy projects: If your app already uses RxJava, this is a consistent approach, but coroutines are a better choice for new projects.

Overall Efficiency Comparison #

内容的提问来源于stack exchange，提问作者Dayyan Nili Sani