音频回调内进程比循环慢且不稳定的原因及优化方法

算力阿峰

2026-6-22

问题

我正在用C++开发一款实时音频应用，需对10ms的音频块进行大量处理，采用miniaudio处理音频I/O。在回调函数内对处理耗时进行基准测试，代码如下：

std::chrono::high_resolution_clock::time_point begin = std::chrono::high_resolution_clock::now();
process_audio(input, output);
std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();

float elapsed_microseconds = (float)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count();

单次处理通常耗时约2.5ms，偶尔低至1.7ms、高达4ms。但在非实时场景（加载音频文件后通过for循环处理，无中断/回调）中，耗时稳定在1.8ms左右，波动极小。

起初我以为是操作系统问题，但在Windows、Mac和Linux上均出现相同情况；也曾怀疑是miniaudio的问题，但改用RtAudio后现象一致。

请问是什么导致回调内的处理更慢且不稳定？有什么优化方法？

补充：最简示例代码

#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"

#include <thread>
#include <chrono>

ma_device_config m_mic_path_config;
ma_device m_mic_device;

int discardCount;
float average_execution_time_usec;
float max_execution_time_usec;
float min_execution_time_usec;
int samples_collected;

float temp = 0;

void zero_vars() {
    discardCount = 0;
    average_execution_time_usec = 0.0f;
    max_execution_time_usec = 0;
    min_execution_time_usec = 1000000;
    samples_collected = 0;
}

void log_measurement(float elapsed_microseconds) {
    // Discard measurements during the first second
    if (discardCount < 10){
        discardCount++;
    }
    else {

        average_execution_time_usec += elapsed_microseconds;
        if (elapsed_microseconds > max_execution_time_usec){
            max_execution_time_usec = elapsed_microseconds;
        }
        if (elapsed_microseconds < min_execution_time_usec){
            min_execution_time_usec = elapsed_microseconds;
        }

        samples_collected++;

    }
}


void print_stats() {

    printf("Min execution time: %0.2f\n", min_execution_time_usec);
    printf("Average execution time: %0.2f\n", average_execution_time_usec / (float) samples_collected);
    printf("Max execution time: %0.2f\n", max_execution_time_usec);
    printf("Samples collected: %d\n", samples_collected);

}

float beefy_process(float num) {

    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();

    for(int i = 0; i < 200000; i++){
        num = num * 1.55;
        num = num + 5;
        num = num / 2.3;
    }

    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

    float elapsed_microseconds = (float)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count();

    log_measurement(elapsed_microseconds);
    return num;
}


void microphone_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount) {    
    temp += beefy_process(5);
}

int start_microphone() {
    ma_result result;

    m_mic_path_config = ma_device_config_init(ma_device_type_capture);
    m_mic_path_config.sampleRate = 48000;
    m_mic_path_config.pUserData = nullptr;
    m_mic_path_config.capture.pDeviceID = NULL; /* system default microphone */
    m_mic_path_config.capture.format = ma_format_s16;
    m_mic_path_config.capture.channels = 1;
    m_mic_path_config.capture.shareMode = ma_share_mode_shared;
    m_mic_path_config.dataCallback = microphone_callback;
    result = ma_device_init(NULL, &m_mic_path_config, &m_mic_device);
    if (result != MA_SUCCESS)
    {
        printf("Failed to set up microphone path. Error: %d", result);
        assert(0);
        return result;
    }

    result = ma_device_start(&m_mic_device);
    if (result != MA_SUCCESS)
    {
        printf("Failed to start microphone path. Error: %d", result);
        assert(0);
        return result;
    }

    return 0;
}



int stop_microphone() {
    ma_result result = ma_device_stop(&m_mic_device);
    if (result != MA_SUCCESS)
    {
        printf("Failed to stop microphone path. Error: %d", result);
        assert(0);
        return result;
    }

    ma_device_uninit(&m_mic_device);

    return 0;
}


int main(int argc, char** argv) {

    printf("NON-REALTIME:\n");

    zero_vars();

    for (int i = 0; i < 300; i++){
        temp += beefy_process(5);
    }
    
    print_stats();
    printf("%f\n", temp); //prevents compiler from optimizing away beefy_process
    

    printf("\nREALTIME:\n");

    zero_vars();

    start_microphone();
    std::this_thread::sleep_for(std::chrono::milliseconds(3 * 1000));
    stop_microphone();

    print_stats();
    printf("%f\n", temp);
    
    return 0;
}

测试结果

NON-REALTIME:
Min execution time: 2004.00
Average execution time: 2494.63
Max execution time: 2987.00
Samples collected: 290
1999.995239

REALTIME:
Min execution time: 2551.00
Average execution time: 3893.67
Max execution time: 4362.00
Samples collected: 291
4006.685547

原因分析与优化方案

核心原因

线程调度优先级：音频回调线程优先级低于系统核心线程（如硬件中断、系统服务线程），操作系统会优先调度高优先级任务，导致回调被抢占，处理时间拉长且不稳定；非实时循环运行在普通线程，调度干扰更少。
CPU缓存失效：非实时循环的访问模式固定，CPU缓存命中率高；音频回调被频繁调度，上下文切换会导致缓存失效，每次回调都要重新加载数据，增加处理时间。
共享设备干扰：示例使用ma_share_mode_shared，音频设备与其他进程共享，系统需要协调多进程访问，额外同步操作会增加回调延迟。
后台系统活动：实时场景下，系统后台的磁盘IO、网络请求、服务更新等会抢占CPU资源，影响回调执行；非实时测试时这些干扰影响被平均或规避。

优化方法

提升回调线程优先级：
- Windows：调用SetThreadPriority设置THREAD_PRIORITY_TIME_CRITICAL
- Linux：用pthread_setschedparam设置SCHED_FIFO或SCHED_RR调度策略
- macOS：通过pthread_setschedparam设置SCHED_FIFO，或使用系统音频API调整优先级
使用独占模式访问设备：将ma_share_mode_shared改为ma_share_mode_exclusive，减少系统协调开销，降低延迟波动。
优化缓存命中率：
- 用aligned_alloc分配对齐内存，让核心数据/代码处于连续内存区域
- 避免在回调中动态分配内存或访问非连续内存块
- 预加载处理所需常量和数据到CPU缓存
剥离非实时操作：把日志、统计等非实时任务移到单独低优先级线程，通过线程安全队列传递数据，示例中的log_measurement必须移出回调。
避免阻塞操作：回调内禁止调用IO、锁等待等可能阻塞的函数，确保代码仅包含纯计算或内存访问。
开启编译器优化：使用-O3等最高级别优化，让编译器自动优化循环和内存访问模式。
绑定CPU核心：将音频回调线程绑定到特定CPU核心，减少跨核心调度带来的缓存失效和延迟。

内容的提问来源于stack exchange，提问作者nukelash

音频回调内进程比循环慢且不稳定的原因及优化方法

核心原因 #

优化方法 #

核心原因

优化方法