Swift：如何等待异步的 @escaping 闭包（内联）

Question

How is it possible to wait for an @escaping closure to complete inline before proceeding?

I am utilizing the write method from AVSpeechSynthesizer, which uses an @escaping closure, so the initial AVAudioBuffer from the callback will return after createSpeechToBuffer has completed.

func write(_ utterance: AVSpeechUtterance, toBufferCallback bufferCallback: @escaping AVSpeechSynthesizer.BufferCallback)

My method writes speech to a buffer, then resamples and manipulates the output, for a workflow, where speech is done in faster than real-time.

The goal is to perform the task inline, to avoid changing the workflow to standby for the 'didFinish' delegate

speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didFinish utterance: AVSpeechUtterance)

I believe this question can be generalized to dealing with @escaping closures within a function\\method

import Cocoa
import AVFoundation

let _speechSynth = AVSpeechSynthesizer()

func resampleBuffer( inSource: AVAudioPCMBuffer, newSampleRate: Float) -> AVAudioPCMBuffer
{
    // simulate resample data here
    let testCapacity     = 1024
    let audioFormat      = AVAudioFormat(standardFormatWithSampleRate: Double(newSampleRate), channels: 2)
    let simulateResample = AVAudioPCMBuffer(pcmFormat: audioFormat!, frameCapacity: UInt32(testCapacity))
    return simulateResample!
}

func createSpeechToBuffer( stringToSpeak: String, sampleRate: Float) -> AVAudioPCMBuffer?
{
    var outBuffer    : AVAudioPCMBuffer? = nil
    let utterance    = AVSpeechUtterance(string: stringToSpeak)
    var speechIsBusy = true
    utterance.voice  = AVSpeechSynthesisVoice(language: "en-us")
    let semaphore = DispatchSemaphore(value: 0)
    
    _speechSynth.write(utterance) { (buffer: AVAudioBuffer) in

        guard let pcmBuffer = buffer as? AVAudioPCMBuffer else {
            fatalError("unknown buffer type: \(buffer)")
        }
        
        if ( pcmBuffer.frameLength == 0 ) {
            print("buffer is empty")
        } else {
            print("buffer has content \(buffer)")
        }
        
        outBuffer    = resampleBuffer( inSource: pcmBuffer, newSampleRate: sampleRate)
        speechIsBusy = false
//        semaphore.signal()
    }
    
    // wait for completion of func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didFinish utterance: AVSpeechUtterance)
    
//        while ( _speechSynth.isSpeaking )
//        {
//            /* arbitrary task waiting for write to complete */
//        }
//
//        while ( speechIsBusy )
//        {
//            /* arbitrary task waiting for write to complete */
//        }
//    semaphore.wait()
    return outBuffer
}

print("SUCCESS is waiting, returning the non-nil output from the resampleBuffer method.")

for indx in 1...10
{
    let sentence  = "This is sentence number \(indx). [[slnc 3000]] \n"
    let outBuffer = createSpeechToBuffer( stringToSpeak: sentence, sampleRate: 48000.0)
    print("outBuffer: \(String(describing: outBuffer))")
}

After I wrote the createSpeechToBuffer method and it failed to produce the desired output (inline), I realized that it returns before getting the results of the resampling. The callback is escaping, so the initial AVAudioBuffer from the callback will return after createSpeechToBuffer has completed. The actual resampling does work, however I currently must save the result and continue after being notified by the delegate "didFinish utterance" to proceed.

Attempts at waiting for _speechSynth.isSpeaking, speechIsBusy flag, dispatch queue and semaphore are blocking the write method (using _speechSynth.write) from completing.

How is it possible to wait for the result inline versus recreating a workflow depending on the delegate "didFinish utterance"?

I'm on macOS 11.4 (Big Sur) but I believe this question is applicable to macOS and ios

Answer 1

It looks to me that the commented-out code for DispatchSemaphore would work if the @escaping closure is run concurrently, and I think the problem is that it is run serially , or more accurately, not run at all, because it is scheduled to run serially. I'm not specifically familiar with the AVSpeechSynthesizer API, but from your description, it sounds to me as though it's calling on the main dispatch queue, which is a serial queue. You call wait to block until _speechSynth.write completes, but that's blocking the main thread, which prevents it from ever continuing to the next iteration of the run loop, so the actual work of _speechSynth.write never even starts.

Let's back up. Somewhere behind the scenes your closure is almost certainly called via DispatchQueue.main 's async method, either because that's where speechSynth.write does its work then calls your closure synchronously on the current thread at the time, or because it explicitly calls it on the main thread.

A lot of programmers are sometimes confused as to exactly what async does. All async means is "schedule this task and return control to the caller immediately". That's it. It does not mean that the task will be run concurrently, only that it will be run later. Whether it is run concurrently or serially is an attribute of the DispatchQueue whose async method is being called. Concurrent queues spin up threads for their tasks, which either can be run in parallel on different CPU cores (true concurrency), or interleaved with the current thread on the same core (preemptive multitasking). Serial queues on the other hand have a run loop as in NSRunLoop , and run their scheduled tasks synchronously after dequeuing them.

To illustrate what I mean, the main run loop looks vaguely like this, and other run loops are similar:

while !quit
{
    if an event is waiting {
        dispatch the event <-- Your code is likely blocking in here
    }
    else if a task is waiting in the queue 
    {
        dequeue the task
        execute the task <-- Your closure would be run here
    }
    else if a timer has expired {
       run timer task
    }
    else if some view needs updating {
        call the view's draw(rect:) method
    }
    else { probably other things I'm forgetting }
}

createSpeechToBuffer is almost certainly being run in response to some event processing, which means that when it blocks, it does not return back to the run loop to continue to the next iteration where it checks for tasks in the queue... which from the behavior you describe, seems to include the work being done by _speechSynth.write ... the very thing you're waiting for.

You can try explicitly creating a .concurrent DispatchQueue and using it to wrap the call to _speechSynth.write in an explicit async call, but that probably won't work, and even if it does, it will be fragile to changes Apple might make to AVSpeechSynthesizer 's implementation.

The safe way is to not block... but that means re-thinking your work flow a little. Basically whatever code would be called after createSpeechToBuffer returns should be called at the end of your closure. Of course, as currently written createSpeechToBuffer doesn't know what that code is (nor should it). The solution is to inject it as a parameter... meaning createSpeechToBuffer itself would also take an @escaping closure. And of course, that means it can't return the buffer, but instead passes it to the closure.

func createSpeechToBuffer(
    stringToSpeak: String,
    sampleRate: Float,
    onCompletion: @escaping (AVAudioPCMBuffer?) -> Void) 
{
    let utterance    = AVSpeechUtterance(string: stringToSpeak)
    utterance.voice  = AVSpeechSynthesisVoice(language: "en-us")
    let semaphore = DispatchSemaphore(value: 0)
    
    _speechSynth.write(utterance) { (buffer: AVAudioBuffer) in

        guard let pcmBuffer = buffer as? AVAudioPCMBuffer else {
            fatalError("unknown buffer type: \(buffer)")
        }
        
        if ( pcmBuffer.frameLength == 0 ) {
            print("buffer is empty")
        } else {
            print("buffer has content \(buffer)")
        }
        
        onCompletion(
            resampleBuffer(
                inSource: pcmBuffer, 
                newSampleRate: sampleRate
            )
        )
    }
}

If you really want to maintain the existing API, the other approach is to move the entire workflow itself to a .concurrent DispatchQueue , which you can block to your heart's content without worry that it will block the main thread. AVSpeechSynthesizer could schedule its work wherever it likes without a problem.

If using Swift 5.5 is an option, you might look into its async and await keywords. The compiler enforces a proper async context for them so that you don't block the main thread.

Update to answer how to call my version.

Let's say your code that calls createSpeechToBuffer currently looks like this:

guard let buffer = createSpeechToBuffer(stringToSpeak: "Hello", sampleRate: sampleRate)
else { fatalError("Could not create speechBuffer") }

doSomethingWithSpeechBuffer(buffer)

You'd call the new version like this:

createSpeechToBuffer(stringToSpeak: "Hello", sampleRate: sampleRate) 
{
    guard let buffer = $0 else {
        fatalError("Could not create speechBuffer")
    }

    doSomethingWithSpeechBuffer(buffer)
}