Замена AsyncTask на java.util.concurrent в Android 11 и выше

Быстрый ответ

Для замены AsyncTask в своих проектах рассмотрите использование ViewModel, LiveData и Coroutines в Kotlin. Этот набор технологий позволяет выполнять асинхронные операции, придерживаясь при этом требований безопасности жизненного цикла:

class MyViewModel : ViewModel() {
    private val mutableLiveData = MutableLiveData<ResultType>()

    fun getLiveData(): LiveData<ResultType> {
        viewModelScope.launch(Dispatchers.IO) {
            val result = doBackgroundWork()
            mutableLiveData.postValue(result)
        }
        return mutableLiveData
    }

    private suspend fun doBackgroundWork(): ResultType {
        return ResultType()
    }
}

В ваших Activity или Fragment:

myViewModel.getLiveData().observe(this, Observer { result ->
    // Обновление UI здесь
})

Добавьте в файл build.gradle следующий список зависимостей:

implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:latest_version'
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:latest_version'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:latest_version'

Таким образом, вы узнали, как заменить использование AsyncTask с помощью ViewModel, LiveData и Coroutines. При этом автоматически происходит отмена операций, если ViewModel уничтожается, что помогает предотвратить утечку памяти.

Подробнее о наборе инструментов

Параллельная работа с ExecutorService и Handlers

ExecutorService и Handler – великолепная замена для AsyncTask, позволяющая выполнять фоновую работу и отправлять результаты на главный поток. Callable станет вашим помощником при выполнении длительных операций.

ExecutorService executorService = Executors.newSingleThreadExecutor();
Handler handler = new Handler(Looper.getMainLooper());

executorService.submit(new Callable<ResultType>() {
    @Override
    public ResultType call() throws Exception {
        return new ResultType();
    }
}).thenAcceptAsync(result -> {
    handler.post(() -> {
        // Обновление главного потока
    });
}, executorService);

В Java 8 и выше используйте лямбда-выражения и ссылки на методы. Этот подход отлично работает начиная с minSdkVersion 16.

Подробнее об этом расскажет наш спикер на видео

Структурированная конкурентность: Глубокое внедрение Kotlin Coroutines

Используйте lifecycleScope или viewModelScope в Kotlin для организации структурированных корутин, которые автоматически отменяются при уничтожении их области видимости, что помогает предотвратить утечку памяти.

lifecycleScope.launch(Dispatchers.IO) {
    // Ваш код для фоновой работы
}.invokeOnCompletion { error ->
    if (error == null) {
        runOnUiThread {
            // Обновление UI
        }
    }
}

Если требуется использовать Context внутри классов или потоков, передавайте его явно или используйте контекст приложения.

Помощь от LiveData

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

Кодирование: правильное управление потоками и обработка исключений

Важно уделять пристальное внимание управлению потоками и обработке исключений, чтобы обеспечить высокую производительность приложения.

Визуализация

Процесс перехода от AsyncTask можно представить как переход от устаревшего транспортного средства к современному:

• Coroutine (🛸): Эффективное выполнение асинхронных задач.
• LiveData (📡): Синхронизация данных в реальном времени.
• RxJava (🚀): Управление потоком данных с поддержкой механизма бэкпресса.

1. Определите все места использования AsyncTask.
2. Выберите наиболее подходящую альтернативу.
3. Замените и отрефакторьте код.

За рамками основ

Лучшие инструменты для повышения производительности

При выборе набора инструментов ориентируйтесь на управление памятью и производительность. Например, ThreadPoolExecutor идеально подходит для сетевых операций или работы с базами данных.

Потоки: Иногда лучше всего простое

В случае простых операций можно использовать класс Threads, при этом не забывать об управлении потоками.

Расширения Kotlin для упорядоченности структуры

Kotlin предлагает расширяющие функции, с помощью которых можно улучшить структуру и читаемость кода.

Класс TaskRunner для структурированного выполнения задач

Создание класса TaskRunner поможет организовать выполнение задач и взаимодействие с главным потоком:

public class TaskRunner<ResultType> {
    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
    private final Handler handler = new Handler(Looper.getMainLooper());

    public void executeAsync(Callable<ResultType> callable, Consumer<ResultType> callback) {
        executorService.submit(callable).thenAcceptAsync(callback, handler);
    }
}

Диспетчеры в Kotlin: выбор подходящего окружения для ваших корутин

Dispatchers позволяют задать поток для корутины: Dispatchers.IO для фоновых задач и Dispatchers.Main для работы с пользовательским интерфейсом.

Полезные материалы

1. Обзор фоновых задач | Разработчики Android — руководство по работе с фоновыми задачами.
2. Управление потоками и персональные сервисы | CodePath Android Cliffnotes — руководство по управлению потоками.
3. Блог разработчиков Android — современные подходы к выполнению фоновых задач в Android.
4. Статья на Medium о переходе с AsyncTask на Kotlin Coroutines- процесс перехода с AsyncTask на Coroutines.
5. Практическое занятие по использованию Kotlin Coroutines в вашем Android приложении | Разработчики Android — справочный материал по Kotlin Coroutines.
6. Планирование задач с WorkManager – Разработчики Android — инструмент для организации фоновых задач.
7. Примеры использования элементов архитектуры – GitHub — примеры проектов с использованием элементов архитектуры.