swift 资源管理&多线程

资源名管理

let img = UIImage(name:"logo")
let btn = UIButton(type:.custom)
btn.setTitle("添加",for:.normal)
performSegue(withIdentifier:"login_main",sender:self)


let img = UIImage(R.image.logo)
let btn = UIButton(type:.custom)
btn.setTitle(R.string.add,for:.normal)
performSegue(withIdentifier:R.segue.,sender:self)

enum R {
    enum string:String {
        case add = "添加"
    }
    enum image:String {
        case logo
    }
    enum segue:String {
        case login_main
    }
    
}

extension UIImage {
    convenience init?(_ name:R.image){
        self.init(name:name.rawValue)
    }
}
extension UIViewController {
    func performSegue(withIdentifier identifier:R.segue,send:Any?){
        performSegue(withIdentifier:identifier.rawValue,sender:sender)
    }
}
extension UIButton {
    func setTitle(_ title:R.string,for state:UIControl.State){
        setTitle(title.rawValue,for:state)
    }
}

// 这种做法实际上是参考了Android的资源名管理方式

资源名管理的其他思路

let img = UIImage(named:"logo")
let font = UIFont(name:"Arial",size;14)

let img = R.image.logo
let font = R.font.arial(14)

enum R {
    enum image {
        static var logo = UIImage(named:'logo')
        
    }
    enum font{
        static func arial(_ size:CGFloat) -> UIFont?{
            UIFont(name:"Arial",size:size)
        }
    }
}

多线程开发-异步

public typealias Task = () ->Void

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

多线程开发-延迟

@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){
 let item = DispatchWorkItem(block:task)
 DispatchQueue.global().asyncAfter(deadline:Dispatch.now() + seconds,execute:item)
 if let main = mainTask {
     item.notify(queue:DispatchQueue.main,execute:main)
 }
}

多线程 - once（static）

多线程- 加锁

public struct Cache {
    private static var data = [String:Any]()
    //private static var lock = DispatchSemaphore(value:1)
   //private static var lock = NSLock()
   private static var lock = NSRecursiveLock()
   public static func get(_ key:String) -> Any? {
       data[key]
   }
   public static func set(_ key:String,_ value:Any){
       //lock.wait()
       //defer{lock.signal()} 解锁
       
       lock.lock()
       defer{lock.unlock()}
       
       data[key] = value
   }
}