Какие примитивы синхронизации могут гарантировать порядок пробуждения потоков

Примитивы синхронизации, гарантирующие порядок пробуждения потоков

В многопоточной разработке для Android (и Java/Kotlin в целом) гарантия порядка пробуждения потоков — важная задача, особенно в сценариях, где требуется строгая очередность выполнения (например, обработка задач в порядке их поступления). Не все стандартные примитивы предоставляют эту гарантию. Рассмотрим основные варианты.

Примитивы с явной гарантированной очередностью

1. FairLock (ReentrantLock с fair = true)

Класс ReentrantLock из java.util.concurrent.locks может работать в двух режимах: несправедливом (default) и справедливом (fair). В справедливом режиме (fair lock) очередь пробуждения соответствует порядку попыток захвата lock.

import java.util.concurrent.locks.ReentrantLock

val fairLock = ReentrantLock(true) // true для fair режима

fun processWithOrder() {
    fairLock.lock()
    try {
        // Критическая секция
        println("Thread ${Thread.currentThread().name} выполняет работу")
    } finally {
        fairLock.unlock()
    }
}

Механизм: При fair режиме внутренняя очередь (обычно FIFO) хранит запросы на lock. Поток, который запросил lock раньше, получит его раньше при освобождении. Это обеспечивает строгий порядок пробуждения, но может снижать производительность из-за дополнительных накладных расходов.

2. Semaphore с fair режимом

Аналогично ReentrantLock, Semaphore может быть создан с параметром fairness.

import java.util.concurrent.Semaphore

val fairSemaphore = Semaphore(1, true) // 1 permit, fair = true

fun accessResource() {
    fairSemaphore.acquire()
    try {
        // Доступ к ограниченному ресурсу
    } finally {
        fairSemaphore.release()
    }
}

Принцип: Semaphore контролирует доступ к ресурсу с ограниченной вместимостью. В fair режиме порядок получения permits соответствует порядку запросов acquire().

Примитивы, которые НЕ гарантируют порядок

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

• synchronized блоки/методы (мониторы) — JVM не гарантирует FIFO порядок для потоков, ожидающих на мониторе.
• ReentrantLock в несправедливом режиме (fair = false) — может давать lock потоку, который запросил его позже, если это эффективнее.
• Object.wait() / notify() — стандартный механизм wait/notify не имеет внутренней очереди порядка пробуждения.

Специализированные структуры для управления порядком

3. BlockingQueue с FIFO порядком

Если задача — обеспечить порядок выполнения задач, часто лучше использовать блокирующую очередь. Например, LinkedBlockingQueue гарантирует FIFO порядок элементов, а методы take() блокируют поток до появления элемента.

import java.util.concurrent.LinkedBlockingQueue

val taskQueue = LinkedBlockingQueue<Runnable>()

// Producer поток добавляет задачи в порядке создания
taskQueue.put(task1)
taskQueue.put(task2)

// Consumer поток берёт задачи строго в порядке FIFO
val nextTask = taskQueue.take() // Блокируется, если очередь пуста
nextTask.run()

Преимущество: Это не примитив синхронизации в классическом смысле, но эффективно решает задачу упорядоченной обработки в многопоточной среде.

4. CyclicBarrier и Phaser (с дополнительной логикой)

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

Ключевые критерии выбора

При выборе примитива для гарантии порядка учитывайте:

1. Производительность vs порядок: Fair режимы (ReentrantLock(true), Semaphore(true)) обеспечивают порядок, но медленнее из-за управления очередью.
2. Конкретная задача: Если нужно упорядочить обработку задач, BlockingQueue часто более удобен и эффективен.
3. Среда выполнения: На Android дополнительные ограничения (меньше ресурсов, важна скорость) могут сделать fair lock менее предпочтительным.

Пример на Kotlin с гарантированным порядком

Рассмотрим сценарий, где несколько потоков должны обновлять UI в строгом порядке их создания.

import java.util.concurrent.locks.ReentrantLock

class OrderedTaskProcessor {
    private val fairLock = ReentrantLock(true)
    
    fun processInOrder(taskId: Int) {
        fairLock.lock()
        try {
            // Выполнение задачи с гарантией порядка захвата lock
            println("Task $taskId выполнен потоком ${Thread.currentThread().name}")
            // Здесь можно, например, обновлять данные для UI
        } finally {
            fairLock.unlock()
        }
    }
}

// Использование в нескольких потоках
fun testOrder() {
    val processor = OrderedTaskProcessor()
    val threads = List(5) { index ->
        Thread {
            processor.processInOrder(index)
        }.also { it.start() }
    }
    threads.forEach { it.join() }
}

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

Вывод

Для гарантии порядка пробуждения потоков в Android/Java разработке основными инструментами являются:

• ReentrantLock с параметром fair = true
• Semaphore с параметром fair = true
• Блокирующие очереди FIFO (LinkedBlockingQueue, ArrayBlockingQueue)

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