图片 loading/caching 关闭主线程

Question

我正在编写一个自定义图像获取器来获取我的 collection 视图所需的图像。下面是我的图片获取逻辑

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 })。我正在从 collectionView 的 cellForRowAt 方法调用 fetchImage 方法，我似乎无法找到一种方法将它从主线程中分派出来，因为我需要请求的 UUID这样我就可以在需要时取消请求。关于如何将其从主线程中删除的任何建议，或者是否有任何建议以更好的方式构建它？

Answer 1

我不认为您的滚动性能与 fetchImage 有关。虽然 Synchronized 中存在适度的性能问题，但可能不足以解释您的问题。话虽如此，这里有几个问题，但阻塞主队列似乎不是其中之一。

更可能的罪魁祸首可能是检索大于图像视图的资产（例如，小图像视图中的大资产需要调整大小，这可能会阻塞主线程）或获取逻辑中的某些错误。当您说“没有看到所需的滚动性能”时，它是卡顿还是缓慢？ “滚动性能”问题的性质将决定解决方案。

一些不相关的观察：

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 倍。而且它是线程安全的。

但是，我们的想法是您不应该公开底层字典，而应该公开同步类型管理字典所需的任何接口。您可能希望在上面添加其他方法（例如 removeAll 或其他），但上面的内容应该足以满足您的直接目的。你应该能够做这样的事情：
```
var dictionary = SynchronizedDictionary<String, UIImage>()

dictionary["foo"] = image
imageView.image = dictionary["foo"]
print(dictionary.count)
```
或者，您可以将字典的所有更新分派到主队列（请参阅下面的第 4 点），然后您根本不需要这种同步字典类型。
您可以考虑使用 NSCache，而不是您自己的字典来保存图像。您要确保对内存压力（清空缓存）或某个固定的总成本限制做出响应。另外，NSCache 已经是线程安全的了。
在 fetchImage 中，您有多个不调用完成处理程序的执行路径。按照惯例，您需要确保始终调用完成处理程序。例如。如果调用者在获取图像之前启动了一个微调器，并在完成处理程序中将其停止怎么办？如果您可能不调用完成处理程序，那么微调器也可能永远不会停止。
同样，在调用完成处理程序的地方，并不总是将其分派回主队列。我要么总是分派回主队列（使调用者不必这样做），要么只从当前队列调用完成处理程序，但只将其中一些分派到主队列会引起混淆。

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

// 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
    }
}

图片 loading/caching 关闭主线程

Image loading/caching off the main thread

multithreading

grand-central-dispatch

barrier

ios

data-synchronization