iOS16+下NWPathMonitor回调触发崩溃问题求助

问题背景 #

在iOS应用中使用Apple的Network框架实现网络状态监听，在应用前后台切换时启停监听逻辑，但应用仅在iOS16+设备上出现崩溃，其中23%的崩溃发生在后台状态，本地无法复现该问题。

实现的监听代码 #

import Foundation
import Network

protocol NWPathMonitorInterface {
    var pathUpdateHandler: ((_ newPath: NWPath) -> Void)? {get set}
    func start(queue: DispatchQueue)
    func cancel()
}

extension NWPathMonitor: NWPathMonitorInterface {}

final class ReachabilityManager {
   
   private(set) var isNetworkAvailable: Bool = false
   private(set) var connectionType: NWInterface.InterfaceType?
   
   private let queue: DispatchQueue
   private var monitor: NWPathMonitorInterface?
   
   public var onUpdateNetworkStatus: ((Bool) -> Void)?
   static let shared = ReachabilityManager(monitor: NWPathMonitor(),
                                           queue: DispatchQueue(label: "com.rapido.networkMonitoring"))

   deinit {
       stopMonitoring()
   }
   
   init(monitor: NWPathMonitorInterface,
        queue: DispatchQueue) {
       self.monitor = monitor
       self.queue = queue
   }
   
   enum ConnectionType {
       case wifi
       case cellular
       case ethernet
   }
   
   public func startMonitoring() {
       if monitor == nil {
           monitor = NWPathMonitor()
       }
       self.monitor?.start(queue: queue)
       self.monitor?
           .pathUpdateHandler = { [weak self] path in
               guard let self = self else { return }
               self.updateStatus(status: path.status)
               self.updateConnectionType(interface: path
                   .availableInterfaces
                   .map(\.type))
       }
   }
   
   
   func updateStatus(status: NWPath.Status) {
       isNetworkAvailable = status == .satisfied ? true : false
       onUpdateNetworkStatus?(isNetworkAvailable)
   }
   
   func updateConnectionType(interface: [NWInterface.InterfaceType]) {
       connectionType = interface.first
   }
   
   func stopMonitoring() {
       monitor?.cancel()
       monitor = nil
   }
}

前后台切换时的启停逻辑 #

func applicationDidBecomeActive(_ application: UIApplication) {
          ReachabilityManager.shared.startMonitoring()
 }

 func applicationDidEnterBackground(_ application: UIApplication) {
        ReachabilityManager.shared.stopMonitoring()
 }

崩溃日志 #

Crashed: com.apple.root.default-qos
0  libswiftCore.dylib             0x3da1bc _swift_release_dealloc + 32
1  libswiftNetwork.dylib          0x372a4 closure #1 in NWPathMonitor.init(requiredInterfaceType:) + 296
2  libswiftNetwork.dylib          0x2470 thunk for @escaping @callee_guaranteed (@guaranteed OS_nw_path) -> () + 52
3  Network                        0x91dad8 __nw_path_evaluator_call_update_handler_block_invoke + 336
4  libdispatch.dylib              0x24b4 _dispatch_call_block_and_release + 32
5  libdispatch.dylib              0x3fdc _dispatch_client_callout + 20
6  libdispatch.dylib              0x70c8 _dispatch_queue_override_invoke + 788
7  libdispatch.dylib              0x15a6c _dispatch_root_queue_drain + 396
8  libdispatch.dylib              0x16284 _dispatch_worker_thread2 + 164
9  libsystem_pthread.dylib        0xdbc _pthread_wqthread + 228
10 libsystem_pthread.dylib        0xb98 start_wqthread + 8

可能的解决思路 #

1. 修复回调与实例释放的竞态问题 #

iOS16+下NWPathMonitor的cancel方法可能是异步执行的，当前代码在stopMonitoring中直接将monitor置为nil，可能导致cancel后仍有回调触发，访问已释放的实例。

修改方案：

• 初始化时一次性设置pathUpdateHandler，避免每次start时重复绑定
• 停止监听时先清空回调，再调用cancel，确保队列处理完成后再释放实例

示例修改：

public func startMonitoring() {
    guard let monitor = monitor else {
        self.monitor = NWPathMonitor()
        // 初始化时绑定回调，避免重复设置
        self.monitor?.pathUpdateHandler = { [weak self] path in
            guard let self = self else { return }
            self.updateStatus(status: path.status)
            self.updateConnectionType(interface: path.availableInterfaces.map(\.type))
        }
        self.monitor?.start(queue: queue)
        return
    }
    // 添加状态标记，避免重复调用start
}

func stopMonitoring() {
    monitor?.pathUpdateHandler = nil // 先清空回调，阻断后续触发
    monitor?.cancel()
    // 切换到监听队列执行释放，确保异步任务完成
    queue.async { [weak self] in
        self?.monitor = nil
    }
}

2. 优化后台状态下的资源管理 #

iOS16+对后台资源管控更严格，后台时直接销毁monitor可能与系统的网络回调产生冲突。

修改方案：

• 后台时不销毁monitor实例，仅清空回调并调用cancel，前台恢复时重新启动监听
• 添加isMonitoring状态标记，防止重复启停引发竞态

3. 避免NWPathMonitor频繁创建销毁 #

当前逻辑每次停止监听都会销毁monitor，下次启动重新创建，这种频繁的生命周期切换在iOS16+下可能引发内部资源清理不彻底的问题。

修改方案：

• 单例初始化时创建一次monitor实例，后续仅调用start/cancel方法，保留实例不销毁
• 确保weak self的捕获逻辑正确，避免循环引用

4. 添加线程安全保护 #

当前对monitor的访问没有做线程同步，主线程调用stop时，回调可能在私有队列执行，引发资源访问冲突。

修改方案：

• 使用串行队列的barrier机制，确保monitor的读写操作是原子性的

示例：

private let accessQueue = DispatchQueue(label: "com.rapido.reachability.access")
private var _monitor: NWPathMonitorInterface?
private var isMonitoring = false

private var monitor: NWPathMonitorInterface? {
    get { accessQueue.sync { _monitor } }
    set { accessQueue.sync(flags: .barrier) { _monitor = newValue } }
}

public func startMonitoring() {
    accessQueue.sync(flags: .barrier) {
        guard !isMonitoring else { return }
        if _monitor == nil {
            _monitor = NWPathMonitor()
            _monitor?.pathUpdateHandler = { [weak self] path in
                guard let self = self else { return }
                self.updateStatus(status: path.status)
                self.updateConnectionType(interface: path.availableInterfaces.map(\.type))
            }
        }
        _monitor?.start(queue: queue)
        isMonitoring = true
    }
}

func stopMonitoring() {
    accessQueue.sync(flags: .barrier) {
        guard isMonitoring else { return }
        _monitor?.pathUpdateHandler = nil
        _monitor?.cancel()
        isMonitoring = false
        // 保留实例，避免频繁创建销毁
        // _monitor = nil
    }
}

内容的提问来源于stack exchange，提问作者SuryaKantSharma