Когда лучше использовать NSLock?

Когда использовать NSLock в iOS/macOS разработке?

NSLock — это простой объектный мьютекс (взаимное исключение) из Foundation, который реализует протокол NSLocking. Его основная задача — обеспечить потокобезопасность при доступе к общим ресурсам в многопоточной среде. Однако в современной iOS-разработке его применение имеет чёткие границы.

Основные сценарии использования NSLock

Я рекомендую NSLock в следующих ситуациях:

1. Защита доступа к простым, неделимым ресурсам или структурам данных. Когда у вас есть небольшой критический участок кода, обращающийся, например, к общему словарю или массиву:

   class ThreadSafeCache {
       private var cache: [String: Data] = [:]
       private let lock = NSLock()
       
       func set(data: Data, for key: String) {
           lock.lock()
           defer { lock.unlock() }
           cache[key] = data
       }
       
       func get(for key: String) -> Data? {
           lock.lock()
           defer { lock.unlock() }
           return cache[key]
       }
   }
   

    Ключевой паттерн здесь — использование `defer { lock.unlock() }`, который гарантирует разблокировку даже при возникновении ошибки или раннем выходе из функции.

1. Когда нужна попытка захвата блокировки без блокировки потока. NSLock предоставляет метод try(), который возвращает Bool. Это полезно, когда вам нужно избежать блокировки потока и выполнить альтернативную логику:

   if lock.try() {
       defer { lock.unlock() }
       // Выполнить критическую операцию
       processCriticalResource()
   } else {
       // Блокировка занята, выполнить фолбэк
       performFallbackAction()
   }
   

2. Для учебных целей или в простых вспомогательных классах. NSLock очень нагляден и прост для понимания концепции мьютекса. В небольших проектах или непереиспользуемых компонентах его использование оправдано.

Когда НЕ стоит использовать NSLock (Альтернативы)

NSLock — низкоуровневая и примитивная блокировка. В сложных современных приложениях я чаще рекомендую другие инструменты:

• Для рекурсивных вызовов — NSRecursiveLock. Обычный NSLock вызовет взаимную блокировку (deadlock), если один и тот же поток попытается захватить его дважды. Если ваш метод может быть вызван рекурсивно (например, из цепочки вызовов или колбэков), используйте NSRecursiveLock.

  class RecursiveProcessor {
      private let recursiveLock = NSRecursiveLock()
      
      func process(value: Int) {
          recursiveLock.lock()
          defer { recursiveLock.unlock() }
          
          if value > 0 {
              // Безопасный рекурсивный вызов
              process(value: value - 1)
          }
      }
  }
  

• Для координации чтения-записи — os_unfair_lock или pthread_rwlock_t. NSLock не различает операции чтения и записи. Если у вас частые операции чтения и редкие записи, эффективнее использовать read-write lock, который позволяет нескольким потокам читать одновременно, но блокирует всех для записи. В Swift для этого часто используют DispatchQueue с атрибутом .concurrent и барьерами (barriers), либо низкоуровневые os_unfair_lock (более эффективный наследник OSSpinLock).

• Для сложной синхронизации или условий — NSCondition или NSConditionLock. Если потокам нужно ждать определенного состояния ресурса (например, "не пусто"), эти классы предоставляют больше возможностей.

• В большинстве высокоуровневых сценариев — Grand Central Dispatch (GCD). Часто проще и безопаснее использовать сериальную очередь (DispatchQueue), которая инкапсулирует синхронизацию. Это более идиоматичный подход для Swift/Objective-C.

  class ModernCache {
      private var cache: [String: Data] = [:]
      private let queue = DispatchQueue(label: "com.example.cache.queue", attributes: .concurrent)
      
      func set(data: Data, for key: String) {
          queue.async(flags: .barrier) { // Барьерная запись
              self.cache[key] = data
          }
      }
      
      func get(for key: String, completion: @escaping (Data?) -> Void) {
          queue.async { // Concurrent чтение
              completion(self.cache[key])
          }
      }
  }
  

• Для современных Swift-проектов — Actor (Swift 5.5+). Это самая современная и безопасная абстракция. Компилятор гарантирует изоляцию данных актора.

  actor ActorCache {
      private var cache: [String: Data] = [:]
      
      func set(data: Data, for key: String) {
          cache[key] = data
      }
      
      func get(for key: String) -> Data? {
          return cache[key]
      }
  }
  

Вывод

Используйте NSLock осознанно:

• Используйте для простейшей защиты маленьких критических секций, где важна минимальная накладная стоимость и нет рекурсии.
• Избегайте в сложной логике, там где есть рекурсия или требуется координация типа "чтение-запись".
• Рассмотрите альтернативы — DispatchQueue, Actor или специализированные блокировки (NSRecursiveLock, os_unfair_lock) — как более безопасные, выразительные или эффективные инструменты в зависимости от контекста.

Главный принцип: чем выше уровень абстракции (DispatchQueue -> Actor), тем меньше шансов ошибиться и создать дедлок или гонку данных (data race). NSLock — это рабочий, но грубый инструмент, требующий от разработчика большой аккуратности.