Почему возникает Priority Inversion?

Что такое Priority Inversion?

Priority Inversion (инверсия приоритетов) — это ситуация в многозадачных системах, особенно с вытесняющей многозадачностью и приоритетным планированием, когда задача с низким приоритетом временно блокирует выполнение задачи с высоким приоритетом, нарушая ожидаемую иерархию приоритетов. Это классическая проблема в операционных системах реального времени (RTOS) и многопоточных средах, включая iOS (Grand Central Dispatch, pthreads).

Почему возникает Priority Inversion?

Основная причина — конкуренция за общие ресурсы (например, мьютексы, семафоры, файлы) в сочетании с некорректной синхронизацией. Рассмотрим классический сценарий из трёх потоков:

📉 Типичный пример:

1. Поток L (Low): низкий приоритет, захватывает общий ресурс (например, блокировка NSLock).
2. Поток H (High): высокий приоритет, пытается захватить тот же ресурс, но блокируется, ожидая освобождения.
3. Поток M (Medium): средний приоритет, не использует ресурс, но готов к выполнению.

Проблема возникает, если планировщик ОС решает запустить поток M, пока L удерживает ресурс, а H ждёт:

• H заблокирован, так как ресурс у L.
• L не может освободить ресурс, так как M с средним приоритетом вытесняет его (поскольку приоритет M > L).
• H фактически ожидает завершения M, хотя M не связан с ресурсом. Приоритет инвертирован: H (высокий) зависит от M (средний), а не только от L (низкий).

// Упрощенный пример на Swift, демонстрирующий риск инверсии
import Foundation

let lock = NSLock()
let highPriorityQueue = DispatchQueue.global(qos: .userInteractive)
let mediumPriorityQueue = DispatchQueue.global(qos: .default)
let lowPriorityQueue = DispatchQueue.global(qos: .background)

lowPriorityQueue.async {
    lock.lock()
    defer { lock.unlock() }
    print("Низкий приоритет: захватил блокировку")
    // Длительная операция...
    Thread.sleep(forTimeInterval: 2)
}

highPriorityQueue.async {
    Thread.sleep(forTimeInterval: 0.1) // Даём L захватить lock первым
    print("Высокий приоритет: пытаюсь захватить блокировку...")
    lock.lock()
    defer { lock.unlock() }
    print("Высокий приоритет: захватил блокировку")
}

mediumPriorityQueue.async {
    Thread.sleep(forTimeInterval: 0.2)
    print("Средний приоритет: выполняю несвязанную работу")
    // M может выполняться, пока L и H заблокированы
}

🔍 Ключевые условия возникновения:

1. Наличие разделяемого ресурса с эксклюзивным доступом.
2. Использование примитивов синхронизации без учёта приоритетов (например, обычные мьютексы).
3. Вытесняющее планирование, где задача с более высоким приоритетом может прервать низкоприоритетную.

🛡️ Решения и профилактика в iOS/macOS:

1. Priority Inheritance (Наследование приоритета)

• Если высокоприоритетный поток ждёт ресурс, удерживаемый низкоприоритетным, приоритет L временно повышается до уровня H. Это предотвращает вытеснение L средними потоками.
• Реализовано в pthread_mutex с атрибутом PTHREAD_PRIO_INHERIT и в некоторых конфигурациях os_unfair_lock.

2. Priority Ceiling (Потолок приоритета)

• Каждому ресурсу назначается максимальный приоритет ("потолок"). Поток, захвативший ресурс, временно получает этот приоритет.
• Используется в реальном времени, в iOS менее распространено.

3. Использование QoS (Quality of Service) в GCD

• GCD автоматически применяет механизмы для смягчения инверсии, но не устраняет её полностью. Важно правильно назначать QoS:

  let queue = DispatchQueue(label: "com.example.queue", 
                            qos: .userInitiated, 
                            attributes: .concurrent)
  

• Избегайте длительных блокировок на главном потоке (QOS_CLASS_USER_INTERACTIVE).

4. Асинхронные API и избегание блокировок

• Используйте async/await, completion handlers, чтобы минимизировать время удержания locks.
• Предпочитайте actor (Swift Concurrency) для изоляции доступа к состоянию:

  actor SharedResource {
      private var data: [String] = []
      func update(_ value: String) {
          data.append(value)
      }
  }
  

5. Инструменты диагностики

• Instruments > Time Profiler для анализа блокировок.
• Thread Sanitizer для обнаружения гонок и проблем синхронизации.

💡 Практический вывод для iOS-разработчика:

Priority Inversion — не просто теоретическая проблема. В iOS она может приводить к "зависанию" интерфейса (т.к. главный поток имеет высокий приоритет) или к срабатыванию watchdog (особенно при работе с UIKit/SwiftUI). Всегда анализируйте критические секции, используйте примитивы синхронизации с поддержкой наследования приоритетов (например, os_unfair_lock с осторожностью) и проектируйте код с минимальным временем удержания блокировок. В современном стеке Swift Concurrency многие проблемы решаются на уровне языка через изолированные actor'ы.