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: $0.url) ?? URL(fileURLWithPath: "") }
                            let language = data.map { $0.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

除非您在completion()中做一些有趣的事情，否则您的DispatchGroup将一直存在，直到requestDownloadLinks在processDownloadData中完成为止。您是通过封闭块将其作为引用从myFunc()传递到requestDownloadLinks的，在其中您调用processDownloadData，将DispatchGroup传递给它。如果未将其传递或保留为引用，否则可能是安全的。为确保使用乐器对您的应用进行配置并检查内存分配和僵尸。您也可以在调试器中检查内存占用量。如果您多次调用myfunc，则应该看到内存稳定增加。

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

1 个答案: