В чем разница между GlobalScope, MainScope и кастомным Scope?

Разница между GlobalScope, MainScope и кастомным Scope в Kotlin Coroutines

В контексте Kotlin Coroutines, Scope (область действия) — это ключевая абстракция для управления жизненным циклом корутин, их структурой и отменой. Различия между GlobalScope, MainScope и кастомными Scope фундаментальны и определяют правильные паттерны использования.

GlobalScope

GlobalScope — это область действия, привязанная к жизненному циклу всего приложения. Это объект-синглтон, определенный в библиотеке coroutines.

object GlobalScope : CoroutineScope {
    override val coroutineContext: CoroutineContext
        get() = EmptyCoroutineContext
}

• Характеристики и риски:

    *   **Жизненный цикл:** Корутины, запущенные в `GlobalScope`, живут до завершения всего приложения. Они не автоматически отменяются при завершении активности, фрагмента или другого компонента UI.
    *   **Контекст:** Использует `EmptyCoroutineContext`, что означает отсутствие привязки к конкретному диспетчеру (например, Main/UI) и отсутствие `Job` для управления отменой группы.
    *   **Основной риск:** Высокая вероятность утечек памяти (`memory leaks`). Если корутина выполняет длительную операцию (сетевой запрос, вычисления) и компонент UI, запустивший ее, уничтожен, корутина продолжит работу, держа ссылки на потенциально уничтоженные объекты.
    *   **Рекомендация:** **Использовать крайне редко или не использовать вообще в Android.** Он предназначен для корутин, которые должны жить весь срок жизни приложения (например, слушатель системных событий), но даже в таких случаях лучше создать явный, управляемый кастомный Scope.

MainScope

MainScope — это функция (factory function), которая создает область действия, привязанную к главному потоку (UI) и имеющую четкую структуру для управления отменой.

fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)

• Характеристики и использование:

    *   **Жизненный цикл:** Созданный scope необходимо явно отменять (`cancel()`) при завершении жизненного цикла компонента. Он не является синглтоном.
    *   **Контекст:** Ключевые элементы:
        *   `Dispatchers.Main`: Все корутины, запущенные в этом scope, по умолчанию будут выполняться на главном потоке (UI). Это безопасно для операций с View.
        *   `SupervisorJob`: `Job`, который управляет жизненным циклом всего scope. Если одна дочерняя корутина падает с исключением (`fails`), это не приводит к автоматической отмене других дочерних корутин (`child coroutines`) — важное отличие от обычного `Job`.
    *   **Идеальный вариант для компонентов Android:** Активности (`Activity`), Фрагмента (`Fragment`) или ViewModel (в сочетании с `viewModelScope`). Пример в Activity:

class MyActivity : AppCompatActivity() {
    private val mainScope = MainScope() // Создаем scope

    override fun onDestroy() {
        super.onDestroy()
        mainScope.cancel() // Явно отменяем все корутины при уничтожении активности
    }

    fun launchUIJob() {
        mainScope.launch {
            // Эта корутина работает на Dispatchers.Main
            updateView()
            val result = withContext(Dispatchers.IO) { // Временно переключаемся на IO для тяжелой работы
                performNetworkRequest()
            }
            processResult(result) // Возвращаемся на Main для обработки результата
        }
    }
}

Кастомный Scope (Custom Scope)

Кастомный Scope — это область действия, которую разработчик создает самостоятельно для конкретных нужд, полностью контролируя его контекст и жизненный цикл. Это наиболее рекомендуемый и гибкий подход.

• Как создать: Реализовать интерфейс CoroutineScope, предоставив свой coroutineContext.
• Контроль над контекстом: Вы можете комбинировать:

    *   **Диспетчер (`Dispatcher`):** `Dispatchers.Main`, `Dispatchers.IO`, `Dispatchers.Default` или даже кастомный пул потоков.
    *   **Job:** `Job()` или `SupervisorJob()` для управления отменой и структурой.
    *   **Обработчик исключений (`CoroutineExceptionHandler`):** Для централизованной обработки неперехваченных исключений в корутинах этого scope.

• Пример кастомного Scope для бизнес-логики:

class DataProcessor {
    // Кастомный scope с SupervisorJob и диспетчером для вычислений
    private val processingScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

    fun processData(data: List<String>) {
        processingScope.launch {
            // Параллельная обработка
            data.map { item ->
                async {
                    heavyComputation(item)
                }
            }.awaitAll()
        }
    }

    fun cleanup() {
        processingScope.cancel() // Отменяем при необходимости
    }
}

• ViewModelScope в Android: Библиотека androidx.lifecycle:lifecycle-viewmodel-ktx предоставляет готовый кастомный Scope — viewModelScope. Он привязан к жизненному циклу ViewModel (отменяется при onCleared()), использует Dispatchers.Main как default и SupervisorJob. Это лучшая практика для работы с корутинами в ViewModel.

Сравнительная таблица и рекомендации

Ключевые выводы и рекомендации:

• Избегайте GlobalScope в Android разработке. Его использование — частый источник утечек памяти и неконтролируемых процессов.
• Используйте MainScope() для компонентов UI, таких как Activity и Fragment, где вам нужен доступ к главному потоку и вы можете явно вызвать cancel() в onDestroy().
• Кастомные Scope — это лучшая практика. Они обеспечивают максимальную гибкость и контроль. Для ViewModel используйте готовый viewModelScope. Для других долгоживущих процессов (сервисы, обработчики данных) создавайте свои scope с подходящим диспетчером и Job, обязательно управляя их отменой.
• Структурная параллельность (structured concurrency) — основная философия, которую реализуют правильные Scope. Дочерние корутины запускаются внутри области действия родителя, их жизненный цикл связан, отмена родителя автоматически отменяет детей, что предотвращает утечки и обеспечивает чистую архитектуру.