Swift：self为nil时如何确保闭包必要逻辑执行且无循环引用

1. 确保日志始终执行：直接捕获logger而非通过self #

logger是类的不可变属性，且你提到单独捕获它不会引发循环引用。直接在闭包捕获列表中加入logger，就能绕过self的生命周期限制，保证日志语句一定会执行：

executor.run { [weak self, logger] result in
    logger.log(msg: "Task done") // 无论self是否释放，此语句都会执行
    // ... 后续逻辑
}

2. 处理someFunctionToCallAfterExecute：抽离逻辑摆脱self依赖 #

既然要求该方法在self释放后仍能执行，说明它的逻辑不应依赖self的可变状态（否则self释放后状态也会消失）。以下两种方式都能解决循环引用问题并保证逻辑执行：

方式一：将逻辑抽离为独立闭包 #

在execute方法内提前定义包含目标逻辑的闭包，仅捕获所需的不可变资源（比如logger），这样闭包无需依赖self即可执行：

class TaskImpl: Task {
    let executor: TaskExecutor
    let logger: Logger

    init(executor: TaskExecutor, logger: Logger) {
        self.executor = executor
        self.logger = logger
    }

    func execute(completion: @escaping (ExecutionResult) -> Void) {
        // 提前封装要执行的逻辑，仅捕获需要的资源
        let postExecuteLogic = { [logger] (result: ExecutionResult) in
            // 原someFunctionToCallAfterExecute的逻辑
            logger.log(msg: "Processing result: \(result)")
            // 其他业务逻辑
        }

        executor.run { [weak self] result in
            logger.log(msg: "Task done")
            postExecuteLogic(result) // 不受self生命周期影响
            completion(result)
        }
    }

    // 若需要对外暴露原方法，可保留并内部调用抽离的逻辑
    func someFunctionToCallAfterExecute(result: ExecutionResult) {
        let postExecuteLogic = { [logger] (result: ExecutionResult) in
            logger.log(msg: "Processing result: \(result)")
        }
        postExecuteLogic(result)
    }

    deinit {
        print("- task deinit")
    }
}

方式二：转为静态方法（逻辑完全不依赖实例时） #

如果someFunctionToCallAfterExecute的逻辑完全不需要访问实例属性或方法，直接将其改为静态方法，闭包中可直接调用，无需捕获self：

class TaskImpl: Task {
    let executor: TaskExecutor
    let logger: Logger

    init(executor: TaskExecutor, logger: Logger) {
        self.executor = executor
        self.logger = logger
    }

    func execute(completion: @escaping (ExecutionResult) -> Void) {
        executor.run { [logger] result in
            logger.log(msg: "Task done")
            // 直接调用静态方法，传入所需参数
            TaskImpl.someFunctionToCallAfterExecute(result: result, logger: logger)
            completion(result)
        }
    }

    static func someFunctionToCallAfterExecute(result: ExecutionResult, logger: Logger) {
        logger.log(msg: "Processing result: \(result)")
        // 其他无状态逻辑
    }

    deinit {
        print("- task deinit")
    }
}

3. 闭包逻辑不依赖实例生命周期的最佳实践 #

• 优先捕获具体资源而非整个实例：对于不需要依赖self的逻辑，直接捕获用到的属性（如logger），避免通过self?.xxx访问，切断逻辑与实例生命周期的绑定。
• 分离无状态逻辑：必须在实例释放后执行的代码，应当设计为无状态或仅依赖传入参数/不可变资源的独立逻辑，不要绑定到实例方法。
• 禁用unowned：永远不要用unowned来假设实例不会释放，weak self是安全选择，但如果逻辑必须执行，就不要让它依赖self的存在。

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