Swift：当调用者 viewController 为 deinit() 时，DispatchQueue.async 调用会发生什么

Question

我正在开发一个 ViewController，我在其中调用了 viewModel 来执行 DispatchQueue.async 调用。在异步任务开始之后和结束之前，我的任务 ViewController 通过按后退按钮来定义。在这种情况下，我的异步任务会发生什么？它会保留线程或内存块或导致内存泄漏吗？如果发生这种情况，有什么办法可以取消我的异步任务吗？

为了理解，我添加了演示类：

Class A: ViewController {
    let viewModel = B()

    func callViewModelAsyncFunction() {
       viewModel.viewModelAsyncFunction()
    }
}

Class B {
    private let sessionQueue = DispatchQueue(label: "Session.Queue")
    private let sessionGroup = DispatchGroup()
    
    func viewModelAsyncFunction() {
       sessionQueue.async {
           self.sessionGroup.wait()
           self.sessionGroup.enter()
        
           //do my other task signal producer call {
           //}
       }
    }
}

Answer 1

由于没有人回答我天真的问题，我做了一些实验，这是我在 Playgrounds 上的实验代码

import Foundation


final class ClassA {
    let viewModel: ViewModel
    let classB: ClassB
    let time: Int
    init(viewModel: ViewModel, classB: ClassB, time: Int) {
        print("Init Class A")
        self.viewModel = viewModel
        self.classB = classB
        self.time = time
    }
    
    func doBackGroundTaskInViewModel() {
        viewModel.doBackGroundTask(anotherClass: classB, completion: {
            print("Block task is done")
        })
    }
    
    deinit {
        
        print("Class A deinited and initTime \(time)")
    }
}

final class ClassB {
    let time: Int
    init(time: Int) {
        print("Init Class B")
        self.time = time
    }
    
    deinit {
        print("Class B deinited and InitTime:\(time)")
    }
    
    func printClassBInformation() {
        sleep(2)
        print("Claas B still alive")
        printCurrentTime()
        
    }
}

final class ViewModel {
    private let sessionQueue = DispatchQueue(label: "Session.Queue")
    private let sessionGroup = DispatchGroup()
    func doBackGroundTask(anotherClass: ClassB, completion:  @escaping() -> Void) {
        sessionQueue.async {
            DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
                printCurrentTime()
                anotherClass.printClassBInformation()
                completion()
            }
        }
    }
    
    init() {
        print("Init Class ViewModel")
    }
    deinit {
        print("ViewModel deinitd")
    }
}

func printCurrentTime () {
    let date = Date()
    let calendar = Calendar.current
    print(calendar.component(.second, from: date))
}



var classA: ClassA? = ClassA(viewModel: .init(), classB: .init(time: 1), time: 1)
printCurrentTime()

classA?.doBackGroundTaskInViewModel()

classA = ClassA(viewModel: .init(), classB: .init(time: 2), time: 2)
classA?.doBackGroundTaskInViewModel()
classA = nil

，实验结果是

Init Class ViewModel
Init Class B
Init Class A
51
Init Class ViewModel
Init Class B
Init Class A
Class A deinited and initTime 1
ViewModel deinitd
Class A deinited and initTime 2
ViewModel deinitd
53
Claas B still alive
55
Block task is done
Class B deinited and InitTime:1
55
Claas B still alive
57
Block task is done
Class B deinited and InitTime:2

从我的实验中，我了解到

1. 异步调用可以保留在线程中，直到线程相关的任务完成
   尽管调用者类已定义，但已完成。
2. 另外，另一点注意到与异步调用相关的变量和完成块保存着内存。