Какие знаешь способы запуска запросов параллельно без использования потоков и корутин?

Запуск параллельных запросов без потоков и корутин

В Android-разработке запуск параллельных запросов традиционно ассоциируется с потоками или корутинами, однако существуют альтернативные подходы, которые позволяют достичь параллелизма без их использования. Эти методы особенно актуальны в контексте реактивного программирования и асинхронных операций.

Основные подходы

1. Использование RxJava / RxKotlin

RxJava предоставляет мощный механизм для параллельного выполнения операций через Schedulers и операторы для работы с параллелизмом:

val disposable = Observable.fromCallable { fetchDataFromSource1() }
    .subscribeOn(Schedulers.io())
    .flatMap { result1 ->
        Observable.fromCallable { fetchDataFromSource2() }
            .subscribeOn(Schedulers.io())
            .map { result2 -> Pair(result1, result2) }
    }
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe({ pair -> 
        // Обработка результатов
    }, { error -> 
        // Обработка ошибок
    })

Ключевые особенности:

• Schedulers.io() управляет пулом потоков для I/O операций
• Оператор subscribeOn определяет, на каком планировщике выполняется источник
• flatMap позволяет запускать параллельные цепочки обработки

2. Применение реактивных потоков (Project Reactor)

Для проектов, использующих Spring WebFlux или подобные фреймворки, можно использовать Reactor:

val result1Mono = Mono.fromCallable { fetchDataFromSource1() }.subscribeOn(Schedulers.parallel())
val result2Mono = Mono.fromCallable { fetchDataFromSource2() }.subscribeOn(Schedulers.parallel())

Mono.zip(result1Mono, result2Mono)
    .subscribe({ tuple -> 
        // Обработка объединенных результатов
    })

3. Callback-based подходы с CompletableFuture (Java 8+)

CompletableFuture предоставляет API для асинхронного программирования через колбэки:

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> fetchDataFromSource1());
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> fetchDataFromSource2());

CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);

combinedFuture.thenRun(() -> {
    try {
        String result1 = future1.get();
        String result2 = future2.get();
        // Обработка результатов
    } catch (Exception e) {
        // Обработка исключений
    }
});

4. Использование AsyncTask (устаревший, но исторически значимый)

Хотя AsyncTask внутренне использует потоки, с точки зрения разработчика он абстрагирует прямое управление потоками:

private inner class MyAsyncTask : AsyncTask<Void, Void, Pair<String, String>>() {
    override fun doInBackground(vararg params: Void): Pair<String, String> {
        val result1 = fetchDataFromSource1()
        val result2 = fetchDataFromSource2()
        return Pair(result1, result2)
    }
    
    override fun onPostExecute(result: Pair<String, String>) {
        // Обновление UI с результатами
    }
}

5. Event-driven архитектура с EventBus

Библиотеки вроде EventBus или Otto позволяют организовать параллельную обработку через систему событий:

// Отправка нескольких событий
EventBus.getDefault().post(DataRequestEvent("source1"))
EventBus.getDefault().post(DataRequestEvent("source2"))

// Обработчики в разных компонентах
@Subscribe(threadMode = ThreadMode.ASYNC)
fun onDataRequest(event: DataRequestEvent) {
    val data = fetchData(event.source)
    EventBus.getDefault().post(DataResponseEvent(data))
}

6. WorkManager для фоновых задач

WorkManager позволяет планировать параллельное выполнение работ:

val workRequest1 = OneTimeWorkRequestBuilder<DataWorker>()
    .setConstraints(constraints)
    .build()

val workRequest2 = OneTimeWorkRequestBuilder<DataWorker>()
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context)
    .beginWith(listOf(workRequest1, workRequest2))
    .enqueue()

Критические замечания и ограничения

Важно понимать, что большинство этих подходов внутренне всё равно используют потоки, но предоставляют более высокоуровневую абстракцию:

• RxJava и Reactor используют планировщики с пулами потоков
• CompletableFuture по умолчанию использует ForkJoinPool
• AsyncTask использует фоновый поток из пула
• Даже колбэк-подходы часто выполняются на фоновых потоках

Рекомендации по выбору подхода

1. Для сложных асинхронных цепочек — RxJava/RxKotlin
2. Для современных Java-проектов — CompletableFuture
3. Для событийно-ориентированных приложений — EventBus/реактивные шины
4. Для фоновых задач с учетом жизненного цикла — WorkManager
5. Для Spring-based проектов — Project Reactor

Все эти методы позволяют организовать параллельное выполнение запросов без явного создания и управления потоками в коде приложения, что улучшает читаемость, тестируемость и снижает вероятность ошибок синхронизации. Однако важно помнить о неявном использовании ресурсов и правильно конфигурировать пулы потоков в каждом конкретном случае.