/**
 多线程开发 – once
 
 dispatch_once在Swift中已被废弃，
 取而代之 可以用 类型属性 或者 全局变量\常量（只初始化一次）
 
 默认自带 lazy + dispatch_once 效果
 */

//全局常量，只初始化一次，只赋值一次，只在使用时才初始化(lazy)
fileprivate let initTask2: Void = {
    print("initTask2---------")
}()



class LCPerson: NSObject {
    var name:String = ""
    var age:Int = 0
    
    //只调用一次，只在使用时才初始化
    static let initTask1: Void = {
        print("initTask1---------")
    }()
    
    
    //单例对象
    static let sharePerson:LCPerson = {
        return LCPerson()
    }()
        

    //MARK: -  person初始化方法
    override init(){
        super.init()
        print("person init")
        let _ = Self.initTask1
        let _ = initTask2
    }
    
    convenience init(name:String,age:Int){
        self.init()
        self.name = name
        self.age = age
    }
    
    convenience init(name:String){
        self.init(name:name,age:0)
    }
    
    convenience init(age:Int){
        self.init(name:"",age:age)
    }
    
    deinit {
        print("deinit")
    }
    
    
    
    
    //MARK: -  异步调用
    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)
    }
    
    
    
    /// 异步调用
    /// - 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)
        }
    }
    
    
    //MARK: -  多线程开发 – 异步延迟
    @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
    }
    
    
    //MARK: -  多线程开发 – 异步延迟
    @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)
    }
    
    
    
    /// 异步延迟
    /// - Parameters:
    ///   - seconds: 延时时间，单位秒
    ///   - task: 在子线程执行的任务
    ///   - mainTask: 子线程任务执行完毕，主线程收到通知后执行的任务
    /// - Returns: 子线程执行的任务
    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
    }
}

/**
 多线程开发 – 加锁
    gcd信号量
 */
class LCCache: NSObject {
    
    private static var data = [String: Any]()
    
    //
    private static var lock1 = DispatchSemaphore(value: 1)
    static func set1(_ key: String, _ value: Any) {
        lock1.wait()
        defer { lock1.signal() }
        data[key] = value
    }
    
    
    //
    private static var lock2 = NSLock()
    static func set2(_ key: String, _ value: Any) {
        lock2.lock()
        defer { lock2.unlock() }
        data[key] = value
    }
    
    
    //
    private static var lock3 = NSRecursiveLock()
    static func set3(_ key: String, _ value: Any) {
        lock3.lock()
        defer { lock3.unlock() }
        data[key] = value
    }
}