弱方法参数语义

Question

有没有办法指定特定方法参数的语义较弱？

详细来说，这是一个按预期工作的 Objective-C 示例代码：

- (void)runTest {  
    __block NSObject *object = [NSObject new];  
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
        [self myMethod:object];  
    });  
    // to make sure it happens after `myMethod:` call  
    dispatch_async(dispatch_get_main_queue(), ^{  
        object = nil;  
    });  
}  
- (void)myMethod:(__weak id)arg0 {  
    NSLog(@"%@", arg0); // <NSObject: 0x7fb0bdb1eaa0>  
    sleep(1);  
    NSLog(@"%@", arg0); // nil  
}  

这是 Swift 版本，不是

public func runTest() {  
    var object: NSObject? = NSObject()  
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {  
        self.myMethod(object)  
    }  
    dispatch_async(dispatch_get_main_queue()) {  
        object = nil  
    }  
}  
private func myMethod(arg0: AnyObject?) {  
    println("\(arg0)") //Optional(<NSObject: 0x7fc778f26cf0>)  
    sleep(1)  
    println("\(arg0)") //Optional(<NSObject: 0x7fc778f26cf0>)  
}  

我是否正确假设在 Swift 版本中的方法调用之间 arg0 无法变为 nil ？ 谢谢！

更新一位来自 Apple Dev.Forums 的用户指出 sleep 不是一个好用的函数，连续的分派可能会导致竞争条件。虽然这些可能是合理的担忧，但这只是一个示例代码，问题的重点是传递弱参数。

Answer 1

Swift 没有“弱 args”……但这可能只是因为 Swift (3.0) args 是不可变的（相当于 lets）和 weak Swift 中的东西需要同时是 var 和Optional.

也就是说，确实有一种非常简单的方法可以实现与弱 args 等效的操作——使用 weak var 本地 （释放要释放的 arg-var）。这是有效的，因为 Swift 直到当前作用域结束时才会挂起 vars（就像 C++ 那样严格）；而是在最后一次使用它们之后从作用域中释放变量 （这使得 lldb-ing 有时成为 PitA，但无论如何）。

以下示例在 macOS 10.11.6 上的 Xcode 8.2.1 上的 Swift 3.0.2 中始终有效：

class Test
{
    func runTest() {
        var object:NSObject? = NSObject()
        myMethod(arg0: object)

        DispatchQueue.main.asyncAfter(
            deadline: DispatchTime.now() + 1.0,
            qos: .userInteractive,
            flags: DispatchWorkItemFlags.enforceQoS
        ){
            object = nil
        }
    }

    func myMethod(arg0:AnyObject?) {
        weak var arg0Weak = arg0
        // `arg0` get “released” at this point.  Note: It's essential that you 
        //   don't use `arg0` in the rest of this method; only use `arg0Weak`.

        NSLog("\(arg0Weak)"); // Optional(<NSObject: 0x600000000810>)

        DispatchQueue.main.asyncAfter(
            deadline: DispatchTime.now() + 2.0,
            qos: .userInteractive,
            flags: DispatchWorkItemFlags.enforceQoS
        ){
            NSLog("\(arg0Weak)"); // nil
        }
    }
}

Test().runTest()

_{请注意，如果您在 Playground 中尝试此操作，则 Playground 将在 DispatchQueues 触发之前完成执行。让可执行文件无限期运行的最简单方法（我所做的）是创建一个新的 Cocoa 应用程序并将上面的所有代码粘贴到 func applicationDidFinishLaunching(_:Notification) { … } （是的，逐字逐句——Swift 允许嵌套在方法中的类定义）.}

---

作为对 thread-safety-leguring 的回应，您已经在示例中使用 dispatch_async 和 sleep 来证明弱 args 确实是真正的交易，这是一个完整的 - main.m-source 测试的单线程和无队列变体：

#import <Foundation/Foundation.h>


@interface Test : NSObject 
- (void)runTest;
- (void)myMethod:(__weak id)arg0 callback:(void (^)())callback;
@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        [[Test new] runTest];
    }
    return 0;
}


@implementation Test

- (void)runTest {
    __block NSObject *object = [NSObject new];
    [self myMethod:object callback:^{
        object = nil;
    }];
}

- (void)myMethod:(__weak id)arg0 callback:(void (^)())callback {
    NSLog(@"%@", arg0); // <NSObject: 0x100400bc0>
    callback();
    NSLog(@"%@", arg0); // (null)
}

@end

Answer 2

暂时无法使用语言语法。

我认为这是目前最接近的解决方法。

public struct Weak<T> where T: AnyObject {
    public weak var object: T?

    public init(_ object: T?) {
        self.object = object
    }
}

func run(_ a: Weak<A>) { 
    guard let a = a.object else { return }
}

Answer 3

有没有办法指定特定方法参数的语义较弱？

这不是您的 Objective-C 代码示例所做的。您意外地获得了几乎弱的语义，并且您具有真正的弱引用所没有的未定义行为（竞争条件）。

myMethod 可以在任何序列点（第一个 NSLog 语句或第二个语句，甚至在 NSLog 的中间某处......即使 ARC 没有忽略）发送消息到 la-la-land arg0 的保留，您仍在竞争主队列释放或更糟 - 保留僵尸对象）。

声明为__block 只是意味着在堆环境中为块分配一个槽（因为dispatch_async 保证让块逃逸，它将从堆栈分配的块提升到堆块，并且其中之一该堆块环境中的存储槽将用于您的__block变量。在ARC下，该块将自动调用Block_copy，也许更恰当地命名为Block_copy_to_heap）。

这意味着块的两个执行实例都将指向同一个内存位置。

如果它有帮助，想象一下这个非常愚蠢的代码，它有一个明显的竞争条件。有 1000 个块同时排队等待修改 unsafe。我们几乎可以保证在 if 块中执行讨厌的语句，因为我们的赋值和比较不是原子的，而且我们正在争夺同一个内存位置。

    static volatile size_t unsafe = 0;

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_apply(1000, queue, ^(size_t instance) {
        unsafe = instance;
        if (unsafe != instance) {
            FORMAT_ALL_STORAGE();
            SEND_RESIGNATION_EMAIL();
            WATCH_THE_WORLD_BURN();
        }
    });

您的 Swift 示例没有同样的问题，因为不修改值的块可能会捕获（并保留）对象，因此看不到其他块的修改。

由闭包的创建者来处理内存管理后果，因此您不能创建在闭包中强制执行不保留循环的 API 合同，除非将某些内容标记为 @noescape 在这种情况下 Swift 赢了'不要做任何保留/释放或其他内存管理，因为该块不会超过当前堆栈帧。出于显而易见的原因，这排除了异步调度。

如果您想提供解决此问题的 API 合约，您可以让类型采用协议 protocol Consumer: class { func consume(thing: Type) }，然后在您的 API 中保留对 Consumer 实例的弱引用。

另一种技术是接受实例函数的柯里化版本并弱捕获self：

protocol Protocol: class { }
typealias FuncType = () -> Void
var _responders = [FuncType]()

func registerResponder<P: Protocol>(responder: P, usingHandler handler: (P) -> () -> Void) {
    _responders.append({ [weak responder] in
        guard let responder = responder else { return }
        handler(responder)()
    })
}

class Inst: Protocol {
    func myFunc() {

    }
}
let inst = Inst()
registerResponder(inst, usingHandler: Inst.myFunc)