如何在不中断主线程的情况下快速延迟 for 循环？

Question

我正在尝试以延迟 0.1 秒的时间读取字符串一个字符，然后再继续读取下一个字符。

我尝试在 for 循环中实现延迟功能，但它有两个问题。 1.延迟不一致，在角色之间移动时所花费的时间不一样。 2.它破坏了我认为是相机视图冻结的原因的主线程。但是，我认为在相机开启时激活手电筒也可能会冻结信号，从而导致故障。

func delay(_ delay:Double, closure:@escaping ()->()) {
    DispatchQueue.main.asyncAfter(
        deadline: DispatchTime.now () + Double(Int64(delay * 
    Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC), execute: 
    closure)
}

func scriptReader(){
    let str = "10101000001111110000110"
    for i in 0..<str.count {

        delay(Double(i) * 0.5) { 
            let index = str.index(str.startIndex, offsetBy:  i) 
            self.flash(number: str[index]) 
        }
    }
}
func flash(number: Character){
    guard let device = AVCaptureDevice.default(for: 
 AVMediaType.video) else { return }
    guard device.hasTorch else { return }

    if number == "0" {
        print("off")
        do {
            try device.lockForConfiguration()

            if (device.torchMode == AVCaptureDevice.TorchMode.on) {
                device.torchMode = AVCaptureDevice.TorchMode.off
            }
            device.unlockForConfiguration()
        } catch {
            print(error)
        }
    }

    if number == "1"{
        print("on")
        do {
            try device.lockForConfiguration()

            if (device.torchMode == AVCaptureDevice.TorchMode.off) {
                do {
                    try device.setTorchModeOn(level: 1.0)
                } catch {
                    print(error)
                }
            }
            device.unlockForConfiguration()
        } catch {
            print(error)
        }
    }
}

Answer 1

您首先关心的是，使用一系列asyncAfter 将遭受“计时器合并”的影响，操作系统将在其中组合未来的、单独安排的计时器以一次全部触发，以充分利用设备电池（操作系统需要唤醒设备的频率越低，电池寿命越长）。计划的计时器越远，操作系统的合并就越多。

可以通过使用重复的Timer 来避免这种情况：

func handle(string: String) {
    guard !string.isEmpty else { return }

    var index = string.startIndex
    Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { timer in
        if string[index] == "0" {
            // handle "0"
        } else {
            // handle not "0"
        }

        index = string.index(after: index)
        if index == string.endIndex  { timer.invalidate() }
    }
}

Answer 2

像这样简单的事情也可能有效：

let threadName = "FlashThread"
let string = "10101000001111110000110"

//Create a custom thread
DispatchQueue(label: threadName).async {
    print("Thread Start")

    //Start loop
    string.forEach { (c) in
        print(c)

        //Do something on main thread
        DispatchQueue.main.async {
            self.flash(number: c)
        }

        //Put your thread to sleep for a second
        sleep(1)
    }

    print("Thread END")
}

Answer 3

我现在已经解决了这个问题。第一个问题是用 Rob 提供的计时器代码解决的。这停止了​​主线程的冻结，现在代码以一致的时间迭代字符串。 第二个问题是通过消除AVCaptureDevice 的多个实例来解决的，一旦解决了代码就可以工作。 感谢您的帮助！

Answer 4

我认为相机冻结是因为你每次在 for 循环中调用它的属性，执行一次，传递它的属性以在你的 func 中获取

试试这个代码来修复你的故障

    func scriptReader(){
    let str = "10101000001111110000110"
    guard let device = AVCaptureDevice.default(for: .video) else { return }
    guard device.hasTorch else { return }
    for i in 0..<str.count {
        DispatchQueue.main.asyncAfter(deadline: .now() + Double(i) * 0.5) {
            let index = str.index(str.startIndex, offsetBy:  i)
            self.flash(number: str[index])
        }
    }
}

func flash(device: AVCaptureDevice, isOn: Bool) {
    do {
        try device.lockForConfiguration()
        device.torchMode = isOn ? AVCaptureDevice.TorchMode.off : device.setTorchModeOn(level: 1.0)
        device.unlockForConfiguration()
    } catch {
        print(error)
    }
}