Какие знаешь проблемы в многопоточности?

Основные проблемы многопоточности в Android-разработке

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

1. Состояние гонки (Race Conditions)

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

class Counter {
    var count = 0
    
    fun increment() {
        count++ // НЕПОТОКОБЕЗОПАСНАЯ операция
    }
}

// Два потока одновременно вызывают increment()
// Результат может быть непредсказуемым

Проблема: операция count++ на самом деле состоит из трёх шагов (чтение, увеличение, запись), которые могут прерываться другими потоками.

2. Взаимная блокировка (Deadlock)

Ситуация, когда два или более потока блокируют друг друга, ожидая ресурсы, занятые другим потоком.

// Классический пример deadlock
val resourceA = Any()
val resourceB = Any()

thread {
    synchronized(resourceA) {
        Thread.sleep(100)
        synchronized(resourceB) { // Ждёт resourceB, но его держит второй поток
            // Критическая секция
        }
    }
}

thread {
    synchronized(resourceB) {
        Thread.sleep(100)
        synchronized(resourceA) { // Ждёт resourceA, но его держит первый поток
            // Критическая секция
        }
    }
}

3. Голодание (Starvation)

Поток не может получить доступ к ресурсам, потому что они постоянно захватываются другими (часто более приоритетными) потоками.

Пример в Android: поток с низким приоритетом пытается получить доступ к UI-потоку, но главный поток постоянно занят обработкой сообщений.

4. Инверсия приоритетов (Priority Inversion)

Поток с низким приоритетом удерживает ресурс, нужный потоку с высоким приоритетом, что фактически снижает приоритет последнего.

5. Проблемы видимости (Visibility Issues)

Изменения, сделанные одним потоком в общих данных, могут быть невидны другим потокам из-за кэширования процессором.

// Без volatile изменения flag могут быть невидны другим потокам
@Volatile
var flag = false

fun startWork() {
    thread {
        while (!flag) { // Может вечно оставаться в цикле без volatile
            // Работа
        }
    }
    
    thread {
        Thread.sleep(1000)
        flag = true // Изменение может не попасть в первый поток
    }
}

6. Активная блокировка (Livelock)

Потоки выполняют работу, но не продвигаются в решении задачи, постоянно реагируя на действия друг друга.

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

7. Проблема производительности

Создание и переключение между потоками — дорогостоящие операции. Слишком много потоков могут снизить производительность из-за:

• Накладных расходов на создание потоков
• Частого переключения контекста
• Конкуренции за ресурсы процессора

Решения и лучшие практики в Android

1. Использование потокобезопасных коллекций из java.util.concurrent:

val concurrentMap = ConcurrentHashMap<String, String>()
val blockingQueue = LinkedBlockingQueue<Data>()

1. Применение корутин вместо прямого управления потоками:

// Корутины решают многие проблемы асинхронности
viewModelScope.launch(Dispatchers.IO) {
    val result = repository.fetchData()
    withContext(Dispatchers.Main) {
        updateUI(result)
    }
}

1. Использование Android-специфичных решений:

• Handler и Looper для работы с главным потоком
• AsyncTask (устаревший, но важный для понимания)
• WorkManager для фоновых задач

1. Применение современных примитивов синхронизации:

// Вместо synchronized используем более гибкие инструменты
val mutex = Mutex()
val semaphore = Semaphore(permits = 3)

suspend fun safeOperation() {
    mutex.withLock {
        // Критическая секция
    }
}

Ключевой принцип: минимизировать разделяемые изменяемые состояния. Если данные должны быть общими — использовать иммутабельные структуры или правильную синхронизацию.

На Android особенно важно помнить о главном потоке UI — все операции с View должны выполняться в нём, в то время как длительные операции (сеть, БД, вычисления) — в фоновых потоках.