Perform data cache lookups on a dedicated queue

Demo/Sources/CustomCacheDemoViewController.swift

@@ -21,12 +21,8 @@ final class CustomCacheDemoViewController: BasicDemoViewController {
 }
 
 extension DFCache: DataCaching {
-    public func cachedData(for key: String, _ completion: @escaping (Data?) -> Void) -> Cancellable {
-        class NoOpCancellable: Cancellable {
-            func cancel() {}
-        }
+    public func cachedData(for key: String, _ completion: @escaping (Data?) -> Void) {
         self.cachedData(forKey: key, completion: completion)
-        return NoOpCancellable()
     }
 
     public func storeData(_ data: Data, for key: String) {

Documentation/Guides/Third Party Libraries.md

@@ -73,12 +73,8 @@ Nuke can be used with any third party caching library.
 
 ```swift
 extension DFCache: DataCaching {
-    public func cachedData(for key: String, _ completion: @escaping (Data?) -> Void) -> Cancellable {
-        class NoOpCancellable: Cancellable {
-            func cancel() {}
-        }
+    public func cachedData(for key: String, _ completion: @escaping (Data?) -> Void) {
         self.cachedData(forKey: key, completion: completion)
-        return NoOpCancellable()
     }
 
     public func storeData(_ data: Data, for key: String) {

Sources/DataCache.swift

@@ -11,7 +11,7 @@ import Foundation
 /// - warning: The implementation must be thread safe.
 public protocol DataCaching {
     /// Retrieves data from cache for the given key.
-    func cachedData(for key: String, _ completion: @escaping (Data?) -> Void) -> Cancellable
+    func cachedData(for key: String, _ completion: @escaping (Data?) -> Void)
 
     /// Stores data for the given key.
     func storeData(_ data: Data, for key: String)
@@ -142,13 +142,10 @@ public final class DataCache: DataCaching {
 
     /// Retrieves data for the given key. The completion will be called
     /// syncrhonously if there is no cached data for the given key.
-    @discardableResult
-    public func cachedData(for key: Key, _ completion: @escaping (Data?) -> Void) -> Cancellable {
-        let work = DispatchWorkItem { [weak self] in
-            completion(self?._getData(for: key))
+    public func cachedData(for key: Key, _ completion: @escaping (Data?) -> Void) {
+        _rqueue.async {
+            completion(self._getData(for: key))
         }
-        _rqueue.async(execute: work)
-        return work
     }
 
     /// Stores data for the given key. The method returns instantly and the data

Sources/ImagePipeline.swift

@@ -136,6 +136,12 @@ public /* final */ class ImagePipeline {
         /// Data loading queue. Default maximum concurrent task count is 6.
         public var dataLoadingQueue = OperationQueue()
 
+        /// Data cache used by the pipeline.
+        public var dataCache: DataCaching?
+
+        /// Data caching queue. Default maximum concurrent task count is 2.
+        public var dataCachingQueue = OperationQueue()
+
         /// Default implementation uses shared `ImageDecoderRegistry` to create
         /// a decoder that matches the context.
         internal var imageDecoder: (ImageDecodingContext) -> ImageDecoding = {
@@ -145,9 +151,6 @@ public /* final */ class ImagePipeline {
         /// Image decoding queue. Default maximum concurrent task count is 1.
         public var imageDecodingQueue = OperationQueue()
 
-        /// Data cache used by the pipeline.
-        public var dataCache: DataCaching?
-
         /// This is here just for backward compatibility with `Loader`.
         internal var imageProcessor: (Image, ImageRequest) -> AnyImageProcessor? = { $1.processor }
 
@@ -206,6 +209,7 @@ public /* final */ class ImagePipeline {
             self.imageCache = imageCache
 
             self.dataLoadingQueue.maxConcurrentOperationCount = 6
+            self.dataCachingQueue.maxConcurrentOperationCount = 2
             self.imageDecodingQueue.maxConcurrentOperationCount = 1
             self.imageProcessingQueue.maxConcurrentOperationCount = 2
         }
@@ -372,19 +376,22 @@ public /* final */ class ImagePipeline {
 
         session.metrics.checkDiskCacheStartDate = Date()
 
-        // Disk cache lookup
-        let task = cache.cachedData(for: key) { [weak self, weak session] data in
-            guard let session = session else { return }
-            session.metrics.checkDiskCacheEndDate = Date()
-            self?.queue.async {
-                if let data = data {
-                    self?._decodeFinalImage(for: session, data: data)
-                } else {
-                    self?._loadData(for: session)
+        let operation = Operation(starter: { [weak self, weak session] finish in
+            cache.cachedData(for: key) { data in
+                guard let session = session else { finish(); return }
+                session.metrics.checkDiskCacheEndDate = Date()
+                self?.queue.async {
+                    finish()
+                    if let data = data {
+                        self?._decodeFinalImage(for: session, data: data)
+                    } else {
+                        self?._loadData(for: session)
+                    }
                 }
             }
-        }
-        session.token.register { task.cancel() }
+        })
+
+        _session(session, enqueue: operation, on: configuration.dataCachingQueue)
     }
 
     private func _loadData(for session: ImageLoadingSession) {

Sources/Internal.swift

@@ -539,14 +539,6 @@ internal struct Printer {
 
 // MARK: - Misc
 
-final class NoOpCancellable: Cancellable {
-    func cancel() {
-        return // Do nothing
-    }
-}
-
-extension DispatchWorkItem: Cancellable {}
-
 struct TaskMetrics {
     var startDate: Date? = nil
     var endDate: Date? = nil