Swift5多线程系列一GCD异步/延时使用初步封装

Swift5多线程系列一GCD异步/延时使用初步封装前言一、封装成基本的struct二、基本使用

1.异步初步任务基本使用2. 延迟执行任务基本使用 总结

上一篇介绍了GCD的基本概率,这篇主要基本实战,初步封装。

Tip: 可以新建一个AsyncStuct.swift,直接当做工具类使用

import Foundation
public typealias Task = () -> Void

struct AsyncStuct {
    
    /// async 追加异步任务
    /// - Parameter task: 异步任务逃逸闭包
    public static func async(_ task: @escaping Task) {
        _async(task)
    }
    
    /// async 追加异步任务,并执行回到主线程任务
    /// - Parameters:
    ///   - task: 异步任务逃逸闭包
    ///   - mainTask: 主线线程逃逸任务
    public static func async(_ task: @escaping Task,
                             _ mainTask: @escaping Task){
        _async(task, mainTask)
    }
    
    
    /// _async 追加异步任务,并执行回到主线程任务具体实现
    /// - Parameters:
    ///   - task: 异步任务逃逸闭包
    ///   - mainTask: 回到主线任务闭包
    private static func _async(_ task: @escaping Task,
                               _ mainTask: Task? = nil){
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().async(execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        
    }
    
    /// 异步延迟任务
    /// - Parameters:
    ///   - seconds: 延时时间
    ///   - task: 延时异步并发任务
    /// - Returns: 延时异步处理的 DispatchWorkItem
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task)
        
    }
    
    /// 异步延迟任务
    /// - Parameters:
    ///   - seconds: 延时时间
    ///   - task: 延时异步并发任务
    ///   - mainTask: 延时异步并发任务回到主线程任务
    /// - Returns: 延时异步处理的 DispatchWorkItem
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task,
                                  _ mainTask: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task, mainTask)
    }
    
    
    
    private static func _asyncDelay(_ seconds: Double,
                                    _ task: @escaping Task,
                                    _ mainTask: Task? = nil) -> DispatchWorkItem{
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + seconds, execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        return item
    }
}

代码如下（示例）：

AsyncStuct.async {
  print("Thread.current -> (Thread.current)")
}
AsyncStuct.async({
    print("Thread.current -> (Thread.current)")
}){
    print("Thread.current -> (Thread.current)")
}

代码如下（示例）：

let dispatchItem = AsyncStuct.asyncDelay(3) {
    print("1Thread.current -> (Thread.current)")
} _: {
    print("2Thread.current -> (Thread.current)")
}

DispatchQueue.global().asyncAfter(deadline: .now() + 0.005) {
    print("Thread.current 被取消 -> (Thread.current)")
    dispatchItem.cancel()
}
print("main Thread.current -> (Thread.current)")

运行结果

main Thread.current -> <_NSMainThread: 0x6000020e8500>{number = 1, name = main}
Thread.current 被取消 -> {number = 4, name = (null)}
2Thread.current -> <_NSMainThread: 0x6000020e8500>{number = 1, name = main}

例如：以上就是今天要讲的内容，本文仅仅简单介绍了swift的异步和延迟基本使用。