方案一：忙等待

忙等待是最简单的处理方式。程序反复检测开关是否关闭，如果不是，则继续检测；如果是，则执行任务。

@IBAction func printHello(_ sender: Any) {
    // 忙等待
    DispatchQueue(label: "default").async {
        while true {
            if self.shouldWaitSwitch.isOn { continue }
            
            print("你好！")
            break
        }
    }
}

@IBOutlet weak var shouldWaitSwitch: UISwitch!

忙等待的优点是实现简单。缺点是忙等待会一直占用CPU。如果预期等待的时间会很长，则应避免使用忙等待。

方案二：延时处理

为避免忙等待一直占用CPU的问题，我们可以使用延迟处理的方式，即创建一个计时器，每间隔一定的时间，就检查一次状态，看可不可以执行。如果可执行，则执行，并终止计时器；如果不能执行，则等待下一次的查看。

@IBAction func printHello(_ sender: Any) {
    // 延迟
    if shouldWaitSwitch.isOn {
        Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true, block: { [unowned self] (timer) in
            if self.shouldWaitSwitch.isOn { return }
            
            print("你好！")
            timer.invalidate()
        })
    }
    else {
        print("你好！")
    }
}

@IBOutlet weak var shouldWaitSwitch: UISwitch!

延迟处理的好处是大大降低了等待时的CPU的占用。缺点是，当开关变为关闭时，不会立即执行，而是可能会有一段间隔。如果时间间隔设置不当，或者开关切换得很频繁，则可能产生饥饿现象。

方案三：消息绑定

消息绑定在开关状态改变时，立即执行相应操作。

@IBAction func printHello(_ sender: Any) {
    // 消息绑定
    if shouldWaitSwitch.isOn {
        if let _ = shouldWaitSwitch.actions(forTarget: self, forControlEvent: .valueChanged) { // already set
            return
        }
        
        shouldWaitSwitch.addTarget(self, action: #selector(printHello(_:)), for: .valueChanged)
    }
    else {
        print("你好！")
    
        if let _ = shouldWaitSwitch.actions(forTarget: self, forControlEvent: .valueChanged) { // if set
            shouldWaitSwitch.removeTarget(self, action: #selector(printHello(_:)), for: .valueChanged)
        }
    }
}

@IBOutlet weak var shouldWaitSwitch: UISwitch!

消息绑定的优点是CPU占用低、响应迅速。缺点是实现起来比较复杂。特别是，一旦绑定了某个操作，这个操作在完成后，要尽量取消绑定，或者使其在开关状态发生改变时，刚好成为不满足运行条件的状态。

队列

上面解决问题的方案，都是只能执行一次打印功能。如果我们需要记录每一次的按钮点击，上面的方案就不适用了。这时我们就需要额外维护一个队列，来记录每一次的点击。这里通过扩展消息绑定的代码来实现这个队列功能。

当开关开启时，如果有任务来，我们就向队列插入一个任务。当开关关闭时，我们执行这个任务。在执行任务之前，我们对于队列进行锁定，此时不能插入新任务，由于我们确认执行时间会很短，所以插入这个新任务的等待这里采用了忙等待。当任务执行完毕后，队列锁定被打开。

@IBAction func printHello(_ sender: Any) {
    // 队列，以消息绑定为例
    if shouldWaitSwitch.isOn {
        while true {
            let isSuccess = WaitingTaskQueue.append(task: "你好！")
            if isSuccess { break } else { continue }
        }
        
        if let _ = shouldWaitSwitch.actions(forTarget: WaitingTaskQueue.self, forControlEvent: .valueChanged) { // already set
            return
        }

        shouldWaitSwitch.addTarget(WaitingTaskQueue.self, action: #selector(WaitingTaskQueue.dealingTasks), for: .valueChanged)
    }
    else {
        print("你好！")
        
        if let _ = shouldWaitSwitch.actions(forTarget: WaitingTaskQueue.self, forControlEvent: .valueChanged) { // if set
            shouldWaitSwitch.removeTarget(WaitingTaskQueue.self, action: #selector(WaitingTaskQueue.dealingTasks), for: .valueChanged)
        }
    }
}

@IBOutlet weak var shouldWaitSwitch: UISwitch!

class WaitingTaskQueue {
    private static var firstItemPosition = 0
    private static var queue:[String] = []
    private static var isLocked = false
    
    @objc static func dealingTasks() {
        guard !isLocked else {
            return
        }
        
        isLocked = true
        
        var relativePosition = 0
        while relativePosition < queue.count {
            print("\(queue[relativePosition]), \(firstItemPosition + relativePosition)")
            relativePosition += 1
        }
        queue.removeAll(keepingCapacity: true)
        firstItemPosition += relativePosition
        
        isLocked = false
    }
    
    static func append(task:String) -> Bool { // is success
        guard !isLocked else {
            return false
        }
        
        queue.append(task)
        
        return true
    }
}

结论

采用消息通知，结合忙等待是最好的方式。延迟技术，存在较大的局限性，例如容易造成饥饿或者任务的执行顺序无序等问题，应该仅在特定的条件下使用。

肇鑫的技术博客

业精于勤，荒于嬉

Swift程序内部对于锁的处理

方案一：忙等待

方案二：延时处理

方案三：消息绑定

队列

结论