Question

我玩过Swift Playground并注意到以下问题：

下面的代码描述了一系列以下列方式相互连接的对象：

objectC --> ObjectB -- weak ref to another C --> another C --> Object B等。

每个objectC由

组成

- a ref to a object B 
- a weak ref to a delegate => this one becomes nil!!

每个objectB由

组成

- A var integer
- A weak ref to another object C

代码执行以下操作：

objectC调用一个函数，比如run()，它将评估（objectB.weak_ref_to_another_C），并在串行队列中调用objectB.weak_ref_to_another_C.run()。

在几次致电.run()之后，C的代表神秘地变成了无...... ....

知道我做错了什么吗？要启动代码，只需在Swift Playground上调用test_recursive_serial()。

let serialQueue = DispatchQueue(label: "myQueue");

public protocol my_protocol:class  {
    func do_something(ofValue:Int,completion:((Int) -> Void))
}

public class classA:my_protocol {

    public let some_value:Int;

    public init(value:Int){
        self.some_value = value;
    }
    public func do_something(ofValue:Int,completion:((Int) -> Void)) {
        print("A:\(some_value) in current thread \(Thread.current) is executing \(Thread.current.isExecuting)");
        if self.some_value == ofValue {
            completion(ofValue);
        }
    }

}

public class classB {

    public weak var jump_to_C:classC?;

    public var value:Int = 0;

}


public class classC {
    weak var delegate:my_protocol?{
        willSet {
            if (newValue == nil) { print("target set to nil") }
            else { print("target set to delegate") }
        }
    }

    var someB:classB?

    public func do_something_else() {
        print(self.delegate!)
    }

    public func do_another(withValue:Int,completion:((Int) -> Void)) {

    }

    public func run(completion:@escaping ((Int) -> Void)) {
        print("\(self.someB?.value)");
        assert(self.delegate != nil, "not here");
        if let obj = someB?.jump_to_C, obj !== self  {
            someB?.value += 1;
            print("\(someB!)")
            usleep(10000);
            if let value = someB?.value, value > 100 {
                completion(someB!.value);
            } else {
                serialQueue.async {
                    print("lauching...")
                    obj.run(completion: completion);
                }
            }
        }else{
            print("pointing to self or nil...\(someB)")
        }
    }
}


public func test_recursive_serial() {

    let my_a = classA(value:100);

    let arrayC:[classC] = (0..<10).map { (i) -> classC in
        let c = classC();
        c.delegate = my_a;
        return c;
    }

    let arrayB:[classB] = (0..<10).map { (i) -> classB in
        let b = classB();
        let ii = (i + 1 >= 10) ? 0 : i + 1;
        b.jump_to_C = arrayC[ii]
        return b;
    }

    arrayC.forEach { (cc) in

        cc.someB = arrayB[Int(arc4random())%arrayB.count];
    }

    arrayC.first!.run() { (value) in
        print("done!");
    }

}

重要提示：如果直接从操场上调用test_recursive_serial()内容，而不是通过功能，则问题不会出现。

编辑：您需要添加＆＃39; PlaygroundPage.current.needsIndefiniteExecution = true＆＃39;到游乐场的代码。

编辑：好的，我觉得我需要添加它。在我身边犯了大错，test_recursive_serial()并没有对任何被调用对象保持引用，所以显然，在代码离开函数后它们都变为零。因此问题。感谢Guy Kogus指出这一点。

最终编辑：添加此内容，希望它可能有所帮助。 Swift游乐场非常适合测试代码，但有时会变得非常繁忙。在当前问题中，解决方案需要先设置变量，然后将它们传递给test_recursive_serial()，这反过来会增加操场的健谈状态。这是保持代码整洁和自包含的另一种选择，同时处理各种风格的异步函数......

如果你有一个异步任务 - 一个不适合网址获取的任务 - 比如说：

myObject.myNonBlockingTask(){ print("I'm done!"}

首先，将XCTest包含在文件的顶部。

import XCTest

然后添加以下内容：

func waitForNotificationNamed(_ notificationName: String,timeout:TimeInterval = 5.0) -> Bool {
    let expectation = XCTNSNotificationExpectation(name: notificationName)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

最后，将完成块更改为：

myObject.myNonBlockingTask(){
    print("I'm done!")
    let name = NSNotification.Name(rawValue: "foobar");
    NotificationCenter.default.post(name:name , object: nil)
}
XCTAssert(waitForNotificationNamed("foobar", timeout: 90));

完整的游乐场代码如下：

public func my_function() {
    let somevar:Int = 123
    let myObject = MyClass(somevar);
    myObject.myNonBlockingTask(){
        print("I'm done!")
        let name = NSNotification.Name(rawValue: "foobar");
        NotificationCenter.default.post(name:name , object: nil)
    }
    XCTAssert(waitForNotificationNamed("foobar", timeout: 90));
}

Playground会在继续之前等待通知，如果超时则会生成异常。在执行完成之前，所有本地创建的对象都将保持有效。

希望这有帮助。

Answer 1

主要问题是你在Playgrounds中测试它，它不一定能很好地与多线程一起使用。在this SO question之后，将test_recursive_serial功能更改为：

arrayC.first!.run() { (value) in
    print("done! \(value)")
    XCPlaygroundPage.currentPage.needsIndefiniteExecution = false
}

XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

while XCPlaygroundPage.currentPage.needsIndefiniteExecution {

}

（您需要在代码顶部添加import XCPlayground才能使其正常运行。）

如果您不添加该代码更改，则在您离开该功能后会释放my_a，这就是delegate在第二次调用nil时变为run的原因}。

我还在run中发现，如果你不像completion那样调用else封闭，那么：

public func run(completion:@escaping ((Int) -> Void)) {
    ...
    if let obj = someB?.jump_to_C, obj !== self  {
        ...
    }else{
        print("pointing to self or nil...\(someB)")
        completion(-1) // Added fallback
    }
}

然后程序卡住了。通过添加它运行到最后，虽然我实际上没有找到原因。

另外，请摆脱所有;，这不是Objective-C

分配到串行队列后，弱引用变为零

1 个答案: