多线程

• 1. 基础信息

    // 主队列
    let mainQueue = DispatchQueue.main
    // 串行队列
    let queue = DispatchQueue(label: "com.syc.nd")
    //获取全局并发队列
    let globleQueue = DispatchQueue.global()
    //获取并发队列
    let queue = DispatchQueue(label: "com.xxx.xxx.queueName", attributes: .concurrent)
    let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: DispatchQoS.default, attributes: [.concurrent, .initiallyInactive], autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.never, target: DispatchQueue?.none)

• 2. 异步

    public typealias Task = () -> Void
    public static func async(_ task: @escaping Task) {
        _async(task)
    }
    public static func async(_ task: @escaping Task,_ mainTask: @escaping Task) {
        _async(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)
        }
    }

• 3. 延迟
  • 主线程延迟

    @discardableResult
    public static func delay(_ seconds: Double,_ block: @escaping Task) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: block)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + seconds,
        execute: item)
        return item
    }

• 异步延迟

    @discardableResult
    public static func asyncDelay(_ seconds: Double,_ task: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task)
    }

    @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
    }

• 4. once dispatch_once在Swift中已被废弃，取而代之可以用类型属性或者全局变量\常量。默认自带 lazy + dispatch_once 效果。

fileprivate let initTask2: Void = {
    print("initTask2---------")
}()
class ViewController: UIViewController {
    static let initTask1: Void = {
        print("initTask1---------")
    }()
    override func viewDidLoad() {
        super.viewDidLoad()
        let _ = Self.initTask1
        let _ = initTask2
    }
}

• 5. 加锁
  • gcd信号量

  class Cache {
      private static var data = [String: Any]()
      private static var lock = DispatchSemaphore(value: 1)
      static func set(_ key: String, _ value: Any) {
          lock.wait() //加锁
          defer { lock.signal() } //方法执行完解锁
          
          data[key] = value
      }
  }

  • Foundation

  // NSLock
  private static var lock = NSLock()
  static func set(_ key: String, _ value: Any) {
      lock.lock()
      defer { lock.unlock() }
  }
  // NSRecursiveLock
  private static var lock = NSRecursiveLock()
  static func set(_ key: String, _ value: Any) {
      lock.lock()
      defer { lock.unlock() }
  }

• iOS多线程—GCD（帮你快速了解Swift GCD）

• swift之GCD基础