Что такое семафоры?

Что такое семафоры?

Семафор — это механизм синхронизации, используемый для управления доступом к общим ресурсам в многопоточных или многопроцессных средах. В контексте Android-разработки семафоры особенно важны при работе с конкурентным выполнением задач, ограничением числа одновременных подключений к сети или доступа к пулам ресурсов (например, потокам в Executor Service).

Основная идея семафора заключается в поддержании счетчика, который определяет, сколько потоков могут одновременно получить доступ к ресурсу. Семафоры были предложены Эдсгером Дейкстрой в 1960-х годах и до сих пор широко применяются в системном программировании.

Типы семафоров

Бинарный семафор

Имеет два состояния: 0 и 1. Фактически работает как мьютекс, но с ключевым отличием: мьютекс должен освобождаться тем же потоком, который его захватил, в то время как семафор может быть освобожден другим потоком. Пример использования — синхронизация двух потоков.

Счетный семафор

Позволяет одновременно работать с ресурсом нескольким потокам, количество которых задается при инициализации семафора. Например, если семафор инициализирован значением 3, то первые три потока получат доступ немедленно, а четвертый будет ждать, пока один из первых не освободит семафор.

Основные операции с семафорами

acquire()

Запрашивает разрешение у семафора. Если счетчик больше нуля, он уменьшается на 1, и поток продолжает выполнение. Если счетчик равен нулю, поток блокируется до тех пор, пока разрешение не станет доступным.

release()

Освобождает разрешение, увеличивая счетчик семафора на 1. При этом один из ожидающих потоков (если такие есть) может получить это разрешение и продолжить работу.

Пример использования в Android/Kotlin

Рассмотрим практический пример — ограничение числа одновременных сетевых запросов:

import java.util.concurrent.Semaphore

class NetworkRequestManager(private val maxConcurrentRequests: Int) {
    private val semaphore = Semaphore(maxConcurrentRequests)
    
    fun executeRequest(requestId: Int) {
        Thread {
            try {
                semaphore.acquire()
                println("Запрос $requestId начал выполнение")
                
                // Имитация сетевого запроса
                Thread.sleep(2000)
                
                println("Запрос $requestId завершен")
            } catch (e: InterruptedException) {
                e.printStackTrace()
            } finally {
                semaphore.release()
            }
        }.start()
    }
}

// Использование
fun main() {
    val manager = NetworkRequestManager(3) // Не более 3 одновременных запросов
    
    // Запускаем 10 запросов
    for (i in 1..10) {
        manager.executeRequest(i)
    }
}

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

Особенности реализации в Java/Android

В Android доступны несколько реализаций семафоров:

1. java.util.concurrent.Semaphore — стандартная реализация из Java Concurrency API
2. kotlinx.coroutines.sync.Semaphore — корутинная реализация для асинхронного кода

Пример с корутинами:

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit

suspend fun limitedOperation(semaphore: Semaphore, id: Int) {
    semaphore.withPermit {
        println("Операция $id началась")
        delay(1000)
        println("Операция $id завершилась")
    }
}

fun main() = runBlocking {
    val semaphore = Semaphore(2) // Два одновременных выполнения
    
    val jobs = List(10) { id ->
        launch {
            limitedOperation(semaphore, id)
        }
    }
    
    jobs.forEach { it.join() }
}

Практическое применение в Android

Семафоры используются в различных сценариях:

• Ограничение одновременных операций ввода-вывода — чтобы не перегружать файловую систему
• Управление пулом соединений с базой данных — контроль максимального числа активных подключений
• Синхронизация доступа к аппаратным ресурсам — например, камере или микрофону
• Реализация паттерна "производитель-потребитель" — для синхронизации потоков
• Rate limiting API вызовов — ограничение частоты запросов к внешним сервисам

Важные аспекты использования

1. Избегайте взаимных блокировок (deadlock) — всегда освобождайте семафоры в finally-блоках
2. Справедливость — Semaphore в Java может работать в fair или unfair режиме. В fair-режиме потоки получают разрешения в порядке очереди, что предотвращает starvation, но снижает производительность
3. Производительность — семафоры легковеснее, чем создание большого количества потоков через Executor с фиксированным пулом

// Пример fair-семафора
val fairSemaphore = Semaphore(3, true) // true - fair режим

Заключение

Семафоры остаются фундаментальным инструментом в арсенале Android-разработчика для решения задач синхронизации и управления ресурсами. Понимание их работы и правильное применение позволяет создавать эффективные, надежные и масштабируемые приложения, особенно в условиях ограниченных ресурсов мобильных устройств. В современной Android-разработке семафоры часто используются вместе с корутинами и другими примитивами синхронизации из пакетов java.util.concurrent и kotlinx.coroutines.