Что применить если блок кода используется несколькими потоками

Управление общим доступом к блоку кода из нескольких потоков

Когда несколько потоков одновременно обращаются к общему блоку кода (критической секции), необходимо применять механизмы синхронизации, чтобы предотвратить состояние гонки (race condition), повреждение данных и недетерминированное поведение приложения. На Android, как и в Java-экосистеме, существует несколько подходов в зависимости от контекста использования.

Основные механизмы синхронизации

1. Ключевое слово synchronized

Наиболее базовый способ в Java для обеспечения взаимного исключения (mutual exclusion).

public class SharedResource {
    private int counter = 0;
    
    // Синхронизированный метод
    public synchronized void increment() {
        counter++; // Критическая секция
    }
    
    // Синхронизированный блок
    public void decrement() {
        synchronized(this) {
            counter--; // Критическая секция
        }
    }
}

Преимущества: Простота использования, встроено в язык. Недостатки: Коarse-grained блокировка может снизить производительность, риск взаимных блокировок (deadlock).

2. ReentrantLock и другие реализации Lock

Более гибкая альтернатива из пакета java.util.concurrent.locks.

import java.util.concurrent.locks.ReentrantLock;

public class SharedResource {
    private final ReentrantLock lock = new ReentrantLock();
    private int value = 0;
    
    public void updateValue(int newValue) {
        lock.lock(); // Получаем блокировку
        try {
            value = newValue; // Критическая секция
            // Другие операции с общими данными
        } finally {
            lock.unlock(); // Всегда освобождаем в finally
        }
    }
}

Преимущества: Возможность tryLock(), fair locking, раздельные read/write блокировки. Недостатки: Необходимость ручного управления блокировкой.

3. Atomic-классы из java.util.concurrent.atomic

Для атомарных операций над отдельными переменными.

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // Атомарная операция
    }
    
    public int getValue() {
        return count.get();
    }
}

Преимущества: Высокая производительность для одиночных переменных, lock-free алгоритмы. Недостатки: Подходят только для простых атомарных операций.

Специфичные для Android подходы

4. Handler и Looper

Для выполнения кода в определенном потоке (например, основном UI-потоке).

class MainActivity : AppCompatActivity() {
    private val mainHandler = Handler(Looper.getMainLooper())
    
    fun updateUIFromBackground() {
        Thread {
            // Фоновая работа
            mainHandler.post {
                // Этот код выполнится в основном потоке
                updateUI()
            }
        }.start()
    }
}

5. Корутины с мьютексами (Kotlin)

В современной Android-разработке на Kotlin.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class SharedData {
    private val mutex = Mutex()
    private var data = 0
    
    suspend fun updateData() {
        mutex.withLock { // Приостановка вместо блокировки потока
            data++ // Критическая секция
        }
    }
}

6. LiveData и StateFlow (Android Architecture Components)

Потоко-безопасные observable-holders для данных.

class ViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(0)
    val uiState: StateFlow<Int> = _uiState.asStateFlow()
    
    fun updateState() {
        _uiState.update { oldValue -> oldValue + 1 } // Потокобезопасно
    }
}

Критерии выбора подхода

1. Для простых операций с примитивами → Atomic классы
2. Для блокировки методов/блоков кода → synchronized или ReentrantLock
3. Для работы в UI-потоке → Handler или корутины с Dispatcher.Main
4. В современных Kotlin-приложениях → корутины с Mutex или потокобезопасные Flow
5. Для общих изменяемых данных → LiveData/StateFlow в архитектуре MVVM

Важные принципы

• Минимизируйте область видимости критической секции — блокируйте только необходимый код
• Избегайте вложенных блокировок для профилактики deadlock
• Всегда освобождайте ресурсы в finally-блоке или используйте try-with-resources
• Рассмотрите неизменяемые (immutable) структуры данных как альтернативу синхронизации
• Для фоновых операций используйте соответствующие Executors и пулы потоков

На Android особенно важно помнить о ANR (Application Not Responding), поэтому длительные операции в синхронизированных блоках могут привести к блокировке UI-потока. Современная рекомендация — использование корутин с structured concurrency и потокобезопасных конструкций из Kotlin, которые обеспечивают более безопасную и эффективную работу с многопоточностью.