Swift跨多Unmanaged实例保留状态：C回调对象提前释放问题

问题场景与代码分析 #

你在调用接收不透明指针和回调的C库时，使用Unmanaged类型处理Swift对象到C指针的转换，但遇到MyThing实例在回调结束后被提前释放的问题。核心需求是：从C库取回指针后，仅当newThing的调用者仍持有该对象引用时，才执行异步块逻辑。

你的原始代码：

func callback(
  opaque: UnsafeMutableRawPointer?,
) {
  let queue: DispatchQueue = // ...
  let thing = Unmanaged<MyThing>.fromOpaque(opaque).takeRetainedValue()
  queue.async { [weak thing] in
    guard let thing else { return }
    // Use thing here
  }
}

func newThing() -> MyThing {
  let thing = MyThing()
  let opaque = Unmanaged.passUnretained(thing).toOpaque()
  my_c_library_function(opaque, callback) // invokes callback(opaque)
  return thing
}

class MyThing {
}

问题根源：passUnretained不会增加对象的引用计数，但回调中takeRetainedValue()会执行一次释放操作，导致MyThing的引用计数被错误减少，即使调用者仍持有引用，对象也可能被提前释放。

解决方案 #

根据C库对不透明指针的持有周期，分两种处理方式：

场景1：C库仅在回调期间持有指针 #

如果C库调用完回调后不再使用该不透明指针，直接调整Unmanaged的方法匹配，避免错误修改引用计数：

func callback(opaque: UnsafeMutableRawPointer?) {
    guard let opaque else { return }
    let queue: DispatchQueue = // 你的目标队列
    // 用takeUnretainedValue获取对象，不修改引用计数
    let thing = Unmanaged<MyThing>.fromOpaque(opaque).takeUnretainedValue()
    queue.async { [weak thing] in
        guard let thing else { return }
        // 在这里安全使用thing
    }
}

func newThing() -> MyThing {
    let thing = MyThing()
    // passUnretained不增加引用计数，由调用者控制对象生命周期
    let opaque = Unmanaged.passUnretained(thing).toOpaque()
    my_c_library_function(opaque, callback)
    return thing
}

class MyThing {
}

这种方式下，MyThing的生命周期完全由newThing的调用者控制：调用者持有引用时，异步块中的weak thing会有值并执行逻辑；调用者释放引用后，异步块会直接返回，不会执行后续操作。

场景2：C库会在回调后持续持有指针 #

如果C库可能多次调用回调，或在回调结束后仍保留指针，需要用passRetained确保对象在C库持有期间不被释放，同时配合清理逻辑避免内存泄漏：

1. 调整指针传递与回调逻辑：

func callback(opaque: UnsafeMutableRawPointer?) {
    guard let opaque else { return }
    let queue: DispatchQueue = // 你的目标队列
    let thing = Unmanaged<MyThing>.fromOpaque(opaque).takeUnretainedValue()
    queue.async { [weak thing] in
        guard let thing else { return }
        // 在这里安全使用thing
    }
}

func newThing() -> MyThing {
    let thing = MyThing()
    // passRetained增加引用计数，确保C库持有期间对象不被释放
    let opaque = Unmanaged.passRetained(thing).toOpaque()
    my_c_library_function(opaque, callback)
    return thing
}

class MyThing {
    // 假设C库提供了清理函数，在不再需要指针时调用
    deinit {
        // 调用C库的清理函数，传入对应的不透明指针
        // my_c_library_cleanup(opaque)
    }
}

2. 当C库不再需要该指针时，调用清理函数释放Unmanaged的引用：

// C库清理函数对应的Swift包装
func my_c_library_cleanup(_ opaque: UnsafeMutableRawPointer?) {
    guard let opaque else { return }
    // 释放passRetained增加的引用计数
    Unmanaged<MyThing>.fromOpaque(opaque).release()
}

这种方式既保证了C库持有期间对象的有效性，又能在对象被调用者释放时，通过deinit触发C库的清理逻辑，避免内存泄漏，同时异步块仍通过weak引用确保仅在对象被持有期间执行。

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