子类化 OperationQueue 添加休眠期

Question

import Foundation

class MyOperationQueue {
    
    static let shared = MyOperationQueue()
    
    private var queue: OperationQueue
    
    init() {
        self.queue = OperationQueue()
        queue.name = "com.myqueue.name"
        queue.maxConcurrentOperationCount = 1
        queue.qualityOfService = .background
    }
    
    func requestDataOperation() {
        queue.addOperation {
            print("START NETWORK \(Date())")
            NetworkService.shared.getData()
            print("END   NETWORK \(Date())")
        }
    }
    
    func scheduleSleep() {
        queue.cancelAllOperations()
        queue.addOperation {
            print("SLEEP START \(Date())")
            Thread.sleep(forTimeInterval: 5)
            print("SLEEP END   \(Date())")
        }
    }
    
    func cancelAll() {
        queue.cancelAllOperations()
    }
}

我每隔 10 秒将requestDataOperation function 放入计时器中。 我有一个手动调用scheduleSleep的按钮。 当我点击按钮时，我应该每 5 秒对请求进行去抖动。

但我得到这样的东西：

START NETWORK
END   NETWORK
SLEEP START   2021-03-11 11:13:40 +0000
SLEEP END     2021-03-11 11:13:45 +0000
SLEEP START   2021-03-11 11:13:45 +0000
SLEEP END     2021-03-11 11:13:50 +0000
START NETWORK
END   NETWORK

如何在我上次点击后增加 5 秒并将其组合在一起而不是将其拆分为两个操作？ 我调用queue.cancelAllOperations并开始新的睡眠操作，但似乎不起作用。

期待结果：

START NETWORK
END   NETWORK
SLEEP START   2021-03-11 11:13:40 +0000
// <- the second tap when 2 seconds passed away
SLEEP END     2021-03-11 11:13:47 +0000  // 2+5
START NETWORK
END   NETWORK

Answer 1

如果你想让一些操作延迟一定时间，我不会创建一个“队列” isReady ，而是我会定义一个Operation直到那个时间过去（例如，五秒后） ). 这不仅消除了对两个独立“睡眠操作”的需要，而且完全消除了它们。

例如，

class DelayedOperation: Operation {
    @Atomic private var enoughTimePassed = false
    private var timer: DispatchSourceTimer?
    private var block: (() -> Void)?

    override var isReady: Bool { enoughTimePassed && super.isReady }    // this operation won't run until (a) enough time has passed; and (b) any dependencies or the like are satisfied

    init(timeInterval: TimeInterval = 5, block: @escaping () -> Void) {
        self.block = block
        super.init()
        resetTimer(for: timeInterval)
    }

    override func main() {
        block?()
        block = nil
    }

    func resetTimer(for timeInterval: TimeInterval = 5) {
        timer = DispatchSource.makeTimerSource()                        // create GCD timer (eliminating reference to any prior timer will cancel that one)
        timer?.setEventHandler { [weak self] in
            guard let self = self else { return }
            self.willChangeValue(forKey: #keyPath(isReady))             // make sure to do necessary `isReady` KVO notification
            self.enoughTimePassed = true
            self.didChangeValue(forKey: #keyPath(isReady))
        }
        timer?.schedule(deadline: .now() + timeInterval)
        timer?.resume()
    }
}

我正在使用以下属性包装器同步我与enoughTimePassed的交互，但您可以使用任何您想要的同步机制：

@propertyWrapper
struct Atomic<Value> {
    private var value: Value
    private var lock = NSLock()

    init(wrappedValue: Value) {
        value = wrappedValue
    }

    var wrappedValue: Value {
        get { synchronized { value } }
        set { synchronized { value = newValue } }
    }

    private func synchronized<T>(block: () throws -> T) rethrows -> T {
        lock.lock()
        defer { lock.unlock() }
        return try block()
    }
}

只要确保isReady是线程安全的。

无论如何，定义了DelayedOperation之后，您就可以做类似的事情

logger.debug("creating operation")

let operation = DelayedOperation {
    logger.debug("some task")
}

queue.addOperation(operation)

它将延迟运行该任务（在这种情况下，只需登录“某些任务”消息）五秒钟。 如果你想重置定时器，只需在操作子类上调用该方法：

operation.resetTimer()

例如，这里我创建了任务，将其添加到队列中，每隔两秒将其重置三次，而该块实际上在最后一次重置后运行了五秒：

2021-09-30 01:13:12.727038-0700 MyApp[7882:228747] [ViewController] creating operation
2021-09-30 01:13:14.728953-0700 MyApp[7882:228747] [ViewController] delaying operation
2021-09-30 01:13:16.728942-0700 MyApp[7882:228747] [ViewController] delaying operation
2021-09-30 01:13:18.729079-0700 MyApp[7882:228747] [ViewController] delaying operation
2021-09-30 01:13:23.731010-0700 MyApp[7882:228829] [ViewController] some task

现在，如果您正在使用网络请求操作，那么您可能已经实现了自己的异步Operation子类，该子类为isFinished 、 isExecuting等执行必要的 KVO，因此您可以选择将上述isReady逻辑与现有Operation结合起来子类。

但是这个想法是可以用异步模式完全失去“睡眠”操作。 如果你确实想要一个专门的睡眠操作，你仍然可以使用上面的模式（但让它成为一个异步操作而不是阻塞一个线程sleep ）。

---

综上所述，如果我个人想要去抖动网络请求，我不会将其集成到操作或操作队列中。 我只会在开始请求时进行去抖：

weak var timer: Timer?

func debouncedRequest(in timeInterval: TimeInterval = 5) {
    timer?.invalidate()
    timer = .scheduledTimer(withTimeInterval: timeInterval, repeats: false) { _ in
        // initiate request here
    }
}