多线程

多线程开发 - 异步

print(Thread.current,"main")
        
        DispatchQueue.global().async {
            print(Thread.current,"async")
            DispatchQueue.main.async {
              //主线程
            }
        }

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

 Asyncs.async({
            //子线程
            print(1,Thread.current)
        }){
            //主线程
            print(2,Thread.current)
        }

多线程 - 延迟

  DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
            //主线程3秒之后执行
        }

多线程 - 异步延迟

 public typealias Task = () -> Void
    
    @discardableResult
    public static func asyncDelay(_ second: Double,
                                  _ task: @escaping Task) -> DispatchWorkItem{
        
        return _asyncDelay(second, task)
    }
    
    @discardableResult
    public static func asyncDelay(_ second: Double,
                                  _ task: @escaping Task,
                                  _ mainTask: Task? = nil) -> DispatchWorkItem{
        
        return _asyncDelay(second, task, mainTask)
    }
    
    private static func _asyncDelay(_ second: Double,
                                    _ task: @escaping Task,
                                    _ mainTask: Task? = nil) -> DispatchWorkItem{
        
        let item  = DispatchWorkItem(block: task)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + second,
                                          execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        return item
    }

discardableResult 就是说返回值可以忽略 不会报错

拿到任务 进行取消
private var item: DispatchWorkItem?
item = Asyncs.asyncDelay(3.0, {
            
        }) {
            
        }
 override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    
        item?.cancel()
    }

多线程 - once

多线程 - 加锁

信号量

public struct Cache {
    
    private static var data = [String: Any]()
    //同时3条线程访问
    private static var lock = DispatchSemaphore(value: 3)
    public static func get(_ key: String) -> Any? {
        return data[key]
    }
    
    public static func set(_ key: String, _ value: Any) {
        lock.wait()
        defer {
            //解锁
            lock.signal()
        }
        data[key] = value
    }
}

NSLock

public struct Cache {
    
    private static var data = [String: Any]()
    private static var lock = NSLock()
    public static func get(_ key: String) -> Any? {
        return data[key]
    }
    
    public static func set(_ key: String, _ value: Any) {
       lock.lock()
       defer {
          lock.unlock()
        }
        data[key] = value
    }
}

有递归调用的使用递归锁

public struct Cache {
    
    private static var data = [String: Any]()

    private static var lock = NSRecursiveLock()
    public static func get(_ key: String) -> Any? {
        return data[key]
    }
    
    public static func set(_ key: String, _ value: Any) {
       
        lock.lock()
        defer {
          lock.unlock()
        }
        data[key] = value
    }
}