GCD 小笔记

下面是学习GCD的一些小笔记，先记下来，到时候忘了还可以再回顾回顾。

Dispatch Async

耗时任务在其它队列异步执行，执行成功后返回到主线程
代码例子：

// background global queue and run the work in the closure asynchronously
DispatchQueue.global(qos: .userInitiated).async { [weak self] in
  guard let self = self else {
    return
  }
  // do some hard thing
  let image = network.fetchImage()
 
  // update ui in main thread
  DispatchQueue.main.async { [weak self] in
    // update main thread imageView image when image downloaded
    self?.imageView.image = image
  }
}

处理读写问题

下面演示了一些单例类处理图片到 添加 和 读取 功能
代码例子：

final class PhotoManager {
    
    /*
     GCD provides an elegant solution of creating a read/write lock
     using dispatch barriers. Dispatch barriers are a group of functions
     acting as a serial-style bottleneck when working with concurrent queues
     
     When you submit a DispatchWorkItem to a dispatch queue you can set flags
     to indicate that it should be the only item executed on the specified
     queue for that particular time. This means that all items submitted to
     the queue prior to the dispatch barrier must complete before the
     DispatchWorkItem will execute.
     
     When the DispatchWorkItem‘s turn arrives, the barrier executes it and
     ensures that the queue does not execute any other tasks during that time.
     Once finished, the queue returns to its default implementation.
     */
    
    private init() {}
    static let shared = PhotoManager()
    
    // create a concurrent queue
    private let concurrentQueue = DispatchQueue(label: "com.zhu.xxxxxxxxxxx", attributes: DispatchQueue.Attributes.concurrent)
   
    private var unsafePhotos: [Photo] = []
    
    // read photos
    var photos: [Photo] {
        var photosCopy: [Photo] = []
        // need photo value, so use sync
        concurrentQueue.sync {
            photosCopy = self.unsafePhotos
        }
        // return the value
        return photosCopy
    }
    
    // add photos
    func addPhoto(_ photo: Photo) {
        // add a barrier to write, act like serial queue now
        concurrentQueue.async(flags: .barrier) { [weak self] in
            guard let self = self else { return }
            
            // add photo
            self.unsafePhotos.append(photo)
            
            // notify main thread
            DispatchQueue.main.async { [weak self] in
                self?.postContentAddedNotification()
            }
        }
    }
}

Dispatch Groups

以下是一个多张图片网络下载的示例

wait() DispatchGroup manages dispatch groups. You’ll first look at its wait method. This blocks your current thread until all the group’s enqueued tasks finish
代码例子：

    func downloadPhotos(withCompletion completion: BatchPhotoDownloadingCompletionClosure?) {
        // async a global queue
        DispatchQueue.global(qos: .userInitiated).async {
            var storedError: NSError?
            
            // a group object
            let downloadGroup = DispatchGroup()
            
            for address in [PhotoURLString.overlyAttachedGirlfriend,
                            PhotoURLString.successKid,
                            PhotoURLString.lotsOfFaces] {
                               
                                // a task start
                                downloadGroup.enter()
                                
                                let url = URL(string: address)
                                let photo = DownloadPhoto(url: url!) { _, error in
                                    if error != nil {
                                        storedError = error
                                    }
                                    // complete that task
                                    downloadGroup.leave()
                                }
                                PhotoManager.shared.addPhoto(photo)
            }
            // will block current thread (use DispatchQueue.global(qos: .userInitiated).async not affect main thread)
            downloadGroup.wait()

            // mission done
            DispatchQueue.main.async {
                completion?(storedError)
            }
        }
    }

但是使用 wait() 会阻塞当前的线程，所以一个更好的方式是使用 notify
代码例子：

    func downloadPhotos(withCompletion completion: BatchPhotoDownloadingCompletionClosure?) {
        var storedError: NSError?
        
        // create a dispathc group
        let downloadGroup = DispatchGroup()
        for address in [PhotoURLString.overlyAttachedGirlfriend,
                        PhotoURLString.successKid,
                        PhotoURLString.lotsOfFaces] {
                            let url = URL(string: address)
                            // start a task
                            downloadGroup.enter()
                            let photo = DownloadPhoto(url: url!) { _, error in
                                if error != nil {
                                    storedError = error
                                }
                                // a task done
                                downloadGroup.leave()
                            }
                            PhotoManager.shared.addPhoto(photo)
        }
        
        // use notify work like asynchronous and not block current thread
        downloadGroup.notify(queue: DispatchQueue.main) {
            completion?(storedError)
        }
    }

任务取消

使用 DispatchWorkItem 模拟任务取消，在代码示例中演示了取消部分图片下载
代码例子：

    func downloadPhotos(withCompletion completion: BatchPhotoDownloadingCompletionClosure?) {
        var storedError: NSError?
        
        // create a dispathc group
        let downloadGroup = DispatchGroup()
        var addresses = PhotoURLString.items
        
        // hold dispatch blocks
        var blocks: [DispatchWorkItem] = []
        
        for index in 0..

参考：

https://www.raywenderlich.com/5370-grand-central-dispatch-tutorial-for-swift-4-part-1-2
https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html
https://developer.apple.com/videos/play/wwdc2016/720/