ios - 图像加载/缓存主线程

Question

我正在编写一个自定义图像 getter 来获取我的收藏 View 所需的图像。下面是我的图像 getter 逻辑

class ImageFetcher {

    /// Thread safe cache that stores `UIImage`s against corresponding URL's
    private var cache = Synchronised([URL: UIImage]())

    /// Inflight Requests holder which we can use to cancel the requests if needed
    /// Thread safe
    private var inFlightRequests = Synchronised([UUID: URLSessionDataTask]())
    
    
    func fetchImage(using url: URL, completion: @escaping (Result<UIImage, Error>) -> Void) -> UUID? {
        /// If the image is present in cache return it
        if let image = cache.value[url] {
            completion(.success(image))
        }
        
        let uuid = UUID()
        
        let dataTask = URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            guard let self = self else { return }
            defer {
                self.inFlightRequests.value.removeValue(forKey:uuid )
            }
            
            if let data = data, let image = UIImage(data: data) {
                self.cache.value[url] = image
                
                DispatchQueue.main.async {
                    completion(.success(image))
                }
                return
            }
            
            guard let error = error else {
                // no error , no data
                // trigger some special error
                return
            }
            
            
            // Task cancelled do not send error code
            guard (error as NSError).code == NSURLErrorCancelled else {
                completion(.failure(error))
                return
            }
        }
        
        dataTask.resume()
        
        self.inFlightRequests.value[uuid] = dataTask
        
        return uuid
    }
    
    func cancelLoad(_ uuid: UUID) {
        self.inFlightRequests.value[uuid]?.cancel()
        self.inFlightRequests.value.removeValue(forKey: uuid)
    }
}

这是一个提供访问缓存所需的线程安全的代码块

/// Use to make a struct thread safe
public class Synchronised<T> {
    private var _value: T
    
    private let queue = DispatchQueue(label: "com.sync", qos: .userInitiated, attributes: .concurrent)
    
    public init(_ value: T) {
        _value = value
    }
    
    public var value: T {
        get {
            return queue.sync { _value }
        }
        set { queue.async(flags: .barrier) { self._value = newValue }}
    }
}

我没有看到所需的滚动性能，我预计这是因为当我尝试访问缓存( queue.sync { _value })时，我的主线程被阻塞了。我调用 fetchImage来自 cellForRowAt 的方法collectionView 的方法，我似乎无法找到一种方法将其从主线程中分派(dispatch)出去，因为我需要请求的 UUID，因此我可以在需要时取消请求。关于如何将其从主线程中删除的任何建议，或者是否有任何建议以更好的方式构建它？

Answer 1

我不相信您的滚动性能与 fetchImage 有关.虽然 Synchronized 中存在适度的性能问题，可能不足以解释您的问题。话虽如此，这里有几个问题，但阻塞主队列似乎不是其中之一。
更可能的罪魁祸首可能是检索大于 ImageView 的 Assets (例如，小 ImageView 中的大 Assets 需要调整大小，这可能会阻塞主线程)或获取逻辑中的一些错误。当您说“没有看到所需的滚动性能”时，它是卡顿还是缓慢？ “滚动性能”问题的性质将决定解决方案。

一些不相​​关的观察:

Synchronised ，与字典一起使用，不是线程安全的。是的，value 的 getter 和 setter是同步的，但不是该字典的后续操作。它也非常低效(尽管，解释您遇到的问题的效率可能不够低)。
我建议不要同步整个字典的检索和设置，而是制作一个同步的字典类型:

public class SynchronisedDictionary<Key: Hashable, Value> {
    private var _value: [Key: Value]

    private let queue = DispatchQueue(label: "com.sync", qos: .userInitiated, attributes: .concurrent)

    public init(_ value: [Key: Value] = [:]) {
        _value = value
    }

    // you don't need/want this
    //
    // public var value: [Key: Value] {
    //     get { queue.sync { _value } }
    //     set { queue.async(flags: .barrier) { self._value = newValue } }
    // }

    subscript(key: Key) -> Value? {
        get { queue.sync { _value[key] } }
        set { queue.async(flags: .barrier) { self._value[key] = newValue } }
    }

    var count: Int { queue.sync { _value.count } }
}

在我的测试中，在发布版本中，这大约快了 20 倍。另外它是线程安全的。
但是，这个想法是您不应该公开底层字典，而只是公开同步类型管理字典所需的任何接口(interface)。您可能希望在上面添加其他方法(例如 removeAll 或其他)，但上面的内容应该足以满足您的直接目的。您应该能够执行以下操作:

var dictionary = SynchronizedDictionary<String, UIImage>()

dictionary["foo"] = image
imageView.image = dictionary["foo"]
print(dictionary.count)

或者，您可以将字典的所有更新分派(dispatch)到主队列(请参见下面的第 4 点)，那么您根本不需要这种同步字典类型。

您可以考虑使用 NSCache ，而不是您自己的字典来保存图像。您希望确保响应内存压力(清空缓存)或某个固定的总成本限制。另外，NSCache已经是线程安全的。

在 fetchImage ，你有几个执行路径，你不调用完成处理程序。按照惯例，您需要确保始终调用完成处理程序。例如。如果调用者在获取图像之前启动了一个微调器，并在完成处理程序中停止它怎么办？如果您可能不调用完成处理程序，那么微调器也可能永远不会停止。

同样，在调用完成处理程序的地方，并不总是将其分派(dispatch)回主队列。我要么总是分派(dispatch)回主队列(使调用者不必这样做)，要么只是从当前队列中调用完成处理程序，但只将其中一些分派(dispatch)到主队列会引起混淆。

FWIW，您可以创建单元测试目标并演示原始 Synchronised 之间的区别和 SynchronisedDictionary , 通过使用 concurrentPerform 测试字典的大规模并发修改:

// this is not thread-safe if T is mutable

public class Synchronised<T> {
    private var _value: T

    private let queue = DispatchQueue(label: "com.sync", qos: .userInitiated, attributes: .concurrent)

    public init(_ value: T) {
        _value = value
    }

    public var value: T {
        get { queue.sync { _value } }
        set { queue.async(flags: .barrier) { self._value = newValue }}
    }
}

// this is thread-safe dictionary ... assuming `Value` is not mutable reference type

public class SynchronisedDictionary<Key: Hashable, Value> {
    private var _value: [Key: Value]

    private let queue = DispatchQueue(label: "com.sync", qos: .userInitiated, attributes: .concurrent)

    public init(_ value: [Key: Value] = [:]) {
        _value = value
    }

    subscript(key: Key) -> Value? {
        get { queue.sync { _value[key] } }
        set { queue.async(flags: .barrier) { self._value[key] = newValue } }
    }

    var count: Int { queue.sync { _value.count } }
}

class SynchronisedTests: XCTestCase {
    let iterations = 10_000

    func testSynchronised() throws {
        let dictionary = Synchronised([String: Int]())

        DispatchQueue.concurrentPerform(iterations: iterations) { i in
            let key = "\(i)"
            dictionary.value[key] = i
        }

        XCTAssertEqual(iterations, dictionary.value.count)  //  XCTAssertEqual failed: ("10000") is not equal to ("834")
    }

    func testSynchronisedDictionary() throws {
        let dictionary = SynchronisedDictionary<String, Int>()

        DispatchQueue.concurrentPerform(iterations: iterations) { i in
            let key = "\(i)"
            dictionary[key] = i
        }

        XCTAssertEqual(iterations, dictionary.count)        // success
    }
}