如何实现Alert真正模态化，避免被异步ViewController覆盖？

这个问题我之前在项目里踩过坑！本质就是两个异步操作抢着修改导航栈——错误Alert的present请求和新ViewController的跳转请求撞在了一起，导致Alert刚弹出来就被覆盖。下面几个亲测有效的方案，你可以根据项目情况选：

方案1：统一弹窗调度中心（推荐） #

最稳妥的方式是把所有弹窗操作都纳入一个串行调度队列，保证同一时间只有一个弹窗操作执行，从根源上避免冲突。

可以写一个单例类来管理所有Alert的present请求：

class AlertDispatcher {
    static let shared = AlertDispatcher()
    // 串行队列，保证弹窗操作顺序执行
    private let dispatchQueue = DispatchQueue(label: "com.yourapp.alert.queue")
    
    func presentAlert(_ alert: UIAlertController) {
        dispatchQueue.async {
            DispatchQueue.main.async {
                // 获取当前最顶层的可弹窗ViewController
                var topVC = UIApplication.shared.keyWindow?.rootViewController
                while let presentedVC = topVC?.presentedViewController {
                    topVC = presentedVC
                }
                
                guard let presentingVC = topVC else { return }
                // 如果当前没有弹窗在显示，直接present
                if presentingVC.presentedViewController == nil {
                    presentingVC.present(alert, animated: true)
                } else {
                    // 如果已有弹窗，先关闭再弹出新的（或者你也可以改成排队等待）
                    presentingVC.presentedViewController?.dismiss(animated: true) {
                        presentingVC.present(alert, animated: true)
                    }
                }
            }
        }
    }
}

之后所有需要弹窗的地方都用这个调度中心：

let errorAlert = UIAlertController(title: "错误", message: "请求失败", preferredStyle: .alert)
errorAlert.addAction(UIAlertAction(title: "确定", style: .default))
AlertDispatcher.shared.presentAlert(errorAlert)

这个方案的优势是：所有弹窗操作串行化，不会出现冲突，还能灵活处理叠加弹窗的逻辑，可扩展性极强。

方案2：监听VC生命周期，延迟弹窗 #

如果不想改太多代码，可以临时用这个方案：在要弹出Alert前，先检查当前ViewController的状态，判断是否正在进行跳转操作，若是则延迟弹窗。

示例代码：

func showErrorAlert(message: String) {
    let alert = UIAlertController(title: "错误", message: message, preferredStyle: .alert)
    alert.addAction(UIAlertAction(title: "确定", style: .default))
    
    guard let rootVC = UIApplication.shared.keyWindow?.rootViewController else { return }
    
    // 检查当前是否有正在进行的present/dismiss操作
    let isNavigating = rootVC.isBeingPresented 
        || rootVC.isBeingDismissed 
        || (rootVC.presentedViewController?.isBeingPresented == true)
    
    if isNavigating {
        // 延迟一段时间再尝试（时间可以根据实际情况调整）
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
            self.showErrorAlert(message: message)
        }
    } else {
        rootVC.present(alert, animated: true)
    }
}

⚠️ 注意：延迟时间不好精准把控，极端情况下还是可能出现冲突，适合临时救急。

方案3：合并异步操作的触发逻辑 #

如果错误检测和HTTP请求这两个异步操作有逻辑关联，可以在HTTP请求完成准备跳转时，先检查是否有待处理的错误：

1. 维护一个全局的错误状态变量，存储待显示的错误信息
2. HTTP请求完成时，先判断是否有未处理的错误，有则先显示Alert，用户确认后再跳转；没有则直接跳转

示例代码：

// 全局存储待显示的错误（可以封装成单例管理）
private var pendingError: String?

// 错误检测时设置待显示错误
func checkForErrorsAsync() {
    DispatchQueue.global().async {
        // 模拟错误检测逻辑
        let errorOccurred = true
        if errorOccurred {
            DispatchQueue.main.async {
                self.pendingError = "请求异常，请稍后重试"
            }
        }
    }
}

// HTTP请求完成后的处理逻辑
func onHttpRequestCompleted() {
    DispatchQueue.main.async {
        if let errorMsg = self.pendingError {
            let alert = UIAlertController(title: "错误", message: errorMsg, preferredStyle: .alert)
            alert.addAction(UIAlertAction(title: "确定", style: .default) { _ in
                self.pendingError = nil
                // 用户确认后再跳转新VC
                self.presentTargetViewController()
            })
            UIApplication.shared.keyWindow?.rootViewController?.present(alert, animated: true)
        } else {
            // 无错误，直接跳转
            self.presentTargetViewController()
        }
    }
}

这个方案适合业务逻辑上错误处理优先于页面跳转的场景。

方案4：用独立UIWindow显示Alert #

如果需要Alert绝对不被任何页面覆盖，可以创建一个独立的UIWindow来承载Alert，让它的层级高于所有其他页面：

func showGlobalModalAlert(message: String) {
    // 创建独立Window
    let alertWindow = UIWindow(frame: UIScreen.main.bounds)
    // 设置层级比系统Alert更高，确保不会被覆盖
    alertWindow.windowLevel = .alert + 1
    // 给Window设置一个空的根VC
    alertWindow.rootViewController = UIViewController()
    // 显示Window
    alertWindow.makeKeyAndVisible()
    
    // 创建Alert
    let alert = UIAlertController(title: "错误", message: message, preferredStyle: .alert)
    alert.addAction(UIAlertAction(title: "确定", style: .default) { _ in
        // 用户点击后隐藏Window，释放资源
        alertWindow.isHidden = true
    })
    
    // 在Window的根VC上present Alert
    alertWindow.rootViewController?.present(alert, animated: true)
}

⚠️ 注意：要保证alertWindow不会被提前释放，你可以把它声明为类的属性，或者用强引用持有它，不然弹窗会一闪而过。

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