如何创建队列并手动启动它

Question

在我的应用程序中，我必须实现刷新令牌逻辑。我希望在刷新令牌过程中发送的所有请求都保存在队列中，一旦我的过程完成，我就会启动队列

例如，我想要这样的东西：

let queue = DispatchQueue(label: "myQueue", attributes: .concurrent)  

queue.async {
    // request One
}

queue.async {
    // request Two
}

当刷新令牌过程完成时：

queue.send()

Answer 1

在我的应用程序中，我必须实现刷新令牌逻辑。我希望在刷新令牌过程中，所有发送的请求都保存在一个队列中，一旦我的过程完成，我就会启动队列

如果要创建队列并延迟其任务的启动，只需将其挂起即可，例如：

let queue = DispatchQueue(label: "myQueue", attributes: .concurrent)  
queue.suspend()

queue.async {
    // request One
}

queue.async {
    // request Two
}

fetchToken { result in
    switch result {
    case .success(let token):
        // do something with token
        print(token)
        queue.resume()

    case .failure(let error):
        // handle the error
        print(error)
    }
}

这就是 suspend 和 resume 调度队列的方式。请注意，suspend 仅阻止项目在队列中启动，但对已经运行的任务没有影响。这就是为什么我在向它分派项目之前暂停队列的原因。

但上述问题引出了你想在那个failure 场景中做什么的问题。你只是有一个队列坐在那里有一堆计划任务。从理论上讲，您可以保留对那些分派块的引用（通过使用DispatchWorkItem 模式而不仅仅是简单的闭包，您可以cancel 这些项目），但我可能会使用操作队列，例如

let queue = OperationQueue()
queue.isSuspended = true

queue.addOperation {
    // request One
}

queue.addOperation {
    // request Two
}

fetchToken { result in
    switch result {
    case .success(let token):
        // do something with token
        print(token)
        queue.isSuspended = false

    case .failure(let error):
        // handle the error
        print(error)
        queue.cancelAllOperations()
    }
}

这和上面的一样，但是我们可以用cancelAllOperations取消所有那些排队的操作。

---

顺便说一句，您可以创建自定义Operation 子类来处理本身是异步的任务。而且我假设您的“请求一”和“请求二”是异步网络请求。请参阅 looking for a specific example where Operation is preferred over GCD or vice-versa 讨论何时可能更喜欢 OperationQueue 而不是 DispatchQueue。

Answer 2

你可以像这样构建一个类

class ConcurrentQueue {

    typealias Task = () -> ()
    private var tasks: [Task] = []
    private let serialQueue = DispatchQueue(label: "Serial queue")

    func enqueueTask(_ task: @escaping Task) {
        serialQueue.sync {
            tasks.append(task)
        }
    }

    func runAndRemoveAllTasks() {
        serialQueue.sync {
            tasks.forEach { task in
                task()
            }
            tasks.removeAll()
        }
    }
}

该类允许您将多个Task(s) 排队。

每个任务都是像() -> Void 这样的闭包。

当你将一个任务加入队列时它不会被执行，它只是被附加到内部数组中。

看

let concurrentQueue = ConcurrentQueue()

concurrentQueue.enqueueTask {
    print("1")
}

concurrentQueue.enqueueTask {
    print("2")
}

concurrentQueue.enqueueTask {
    print("3")
}

这段代码的结果只是保存了 3 个任务，它们没有被执行。

然后当你打电话时

concurrentQueue.runAndRemoveAllTasks()

所有的任务都被执行并在你得到的控制台中

1
2
3

线程安全

enqueueTask(_) 和 runAndRemoveAllTasks() 方法是线程安全的。

事实上，它们只在内部与内部tasks 数组（不是隐式线程安全的）交互

serialQueue.sync {
   ...
}

这保证了对tasks 数组的一致访问。

Answer 3

解决方法是使用BlockOperation：

let pendingRequests = BlockOperation()

pendingRequests.addExecutionBlock {
    //Adding first request
}

pendingRequests.addExecutionBlock {
    //Adding second request
}

当刷新令牌完成时：

pendingRequests.start()