使用内部闭包时可能会发生内存泄漏

Question

我想确保我没有发生以下内存泄漏。现在为了抛出错误从我的代码中使用 ooder 中的网络调用来让它工作我必须保留对我的 dispatchgroup 和 function 的引用来处理数据。

   func myFunc(
               completion: @escaping (_ success: () throws -> Bool) -> Void) {

                let fG = DispatchGroup()
                let processLinks = self.processDownloadData
                requestDownloadLinks(fromURL: url) { result in
                    switch result {
                    case .success(let data):
                        processLinks(data, fG, stagingBundle, {_ in
                            switch result {
                            case .failure(let error):
                                completion({ throw error })
                            case .success:
                                completion({ return true })
                            }
                        })
                    case .failure(let error):
                        completion({ return true }) 
                    }
                }

其中 processDownloadData

    func processDownloadData(
        data: ((urls: [(url: URL, language: String)], version: String)),
        dispatchGroup: DispatchGroup),
        completion: @escaping (_ success: () throws -> Bool) -> Void) {
//write data 
}

和requestDownloadLinks

  final func requestDownloadLinks(
        fromURL url: URL,
        completion: ((Result<(urls: [(url: URL, language: String)],
        version: String), Error>) -> Void)?  = nil
    ) {
        DispatchQueue.global(qos: .background).async { [weak self] in
            guard let self = self else {return}
            self.httpManager?.get(url: url) {result in
                switch result {
                case .failure(let error):
                    if let completion = completion {
                        completion(.failure(LokalisationError.network(originatingError: error)))
                    }
                case .success(let data):
                    do {
                        guard let data = data as? Data else {
                            if let completion = completion {
                                completion(.failure(LokalisationError.malformedDataFromServer))
                            }
                            return
                        }
                        let decoder = JSONDecoder()
                        let contents = try decoder.decode(EndPointResponse.self, from: data)
                        if let data = contents.data {
                            let urls = data.map { URL(string: [=12=].url) ?? URL(fileURLWithPath: "") }
                            let language = data.map { [=12=].language }
                            let urlsForLang = Array(zip(urls, language))
                            if let completion = completion {
                                completion(.success( (urlsForLang, contents.version) ))
                            }
                        }
                    } catch let error {
                        if let completion = completion {
                            completion(.failure(LokalisationError.network(originatingError: error)))
                        }

     }
                }
            }
        }
    }

现在这样做是不是造成了内存泄漏？当我创建对 dispatchgroup 和函数的引用时，我认为它们在 http 调用完成之前不会被释放。现在可以了，因为它要么成功完成，要么出错。或者这会导致内存泄漏吗？

Answer 1

您的 DispatchGroup 将一直存在，直到 completion() 在 requestDownloadLinks 完成，除非您在 processDownloadData 用它做一些有趣的事情。您通过闭包块将其作为引用从 myFunc() 传递到 requestDownloadLinks，在闭包块中您调用 processDownloadData 将 DispatchGroup 传递给它。如果它没有被传递或作为参考保存在其中，那么您可能是安全的。确保使用 Instruments 分析您的应用程序并检查内存分配和僵尸程序。您还可以在调试器中检查内存占用。如果您多次调用 myfunc，您应该会看到内存稳定增加。

使用内部闭包时可能会发生内存泄漏

Possible memory leak when using an inner closure

memory-leaks

swift