音频开发 / 系统课时

用无锁队列传递控制参数

用无锁队列传递控制参数

UI 线程可以在任意时刻修改多个音频参数,但音频线程不能为了“读到完整参数”去等待互斥锁。本节用单生产者单消费者队列传递不可分割的参数快照,让控制线程负责发布、音频线程负责消费,并验证每次读到的都是同一版本的数据。

学习目标

  • 理解 SPSC 队列为什么适合“一个控制生产者 + 一个音频消费者”的参数通道。
  • 用完整快照避免多个相关参数分别更新时出现中间态或参数撕裂。
  • 正确使用原子索引和 acquire/release 内存序,并用并发测试验证一致性。

先区分单值参数和组合参数

一个独立参数,例如总增益,通常可以直接放进 std::atomic<float>:控制线程写新值,音频线程在块边界读取即可。问题出现在多个值必须保持同一版本时。

假设 UI 同时更新 dry/wet,使两者之和始终为 1000。如果分别写两个原子变量,音频线程可能先读到新的 dry,再读到旧的 wet,从而短暂得到一个从未真正发布过的组合。解决方法是把相关字段组成一个 ParamSnapshot,作为整体通过队列发布。

SPSC 参数快照从控制线程流向音频线程

SPSC 的优势在于角色固定:只有生产者写 head,只有消费者写 tail。两端通过原子索引观察彼此进度,不需要互斥锁,也不会出现多个生产者争抢同一写位置的问题。

用固定容量环形队列发布快照

下面实现容量为 64 的 SPSC 队列。生产者先把完整对象写入槽位,再以 release 语义发布新的 head;消费者用 acquire 读取 head 后,才能安全看到对应槽位内容。

cpp
#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <thread>

struct ParamSnapshot {
    std::uint64_t version;
    int dryMilli;
    int wetMilli;
};

template <typename T, std::size_t Capacity>
class SpscQueue {
public:
    bool push(const T& value) noexcept {
        const auto head = head_.load(std::memory_order_relaxed);
        const auto next = (head + 1) % Capacity;

        // next == tail 表示队列已满,生产者不能覆盖消费者尚未读取的数据。
        if (next == tail_.load(std::memory_order_acquire)) {
            return false;
        }

        buffer_[head] = value;
        head_.store(next, std::memory_order_release);
        return true;
    }

    bool pop(T& value) noexcept {
        const auto tail = tail_.load(std::memory_order_relaxed);

        if (tail == head_.load(std::memory_order_acquire)) {
            return false;
        }

        value = buffer_[tail];
        tail_.store((tail + 1) % Capacity, std::memory_order_release);
        return true;
    }

private:
    std::array<T, Capacity> buffer_{};
    std::atomic<std::size_t> head_{0};
    std::atomic<std::size_t> tail_{0};
};

int main() {
    SpscQueue<ParamSnapshot, 64> queue;
    std::atomic<bool> producerDone{false};
    std::atomic<int> tornSnapshots{0};
    std::atomic<int> consumed{0};

    std::thread producer([&] {
        for (std::uint64_t version = 1; version <= 50000; ++version) {
            const int dry = static_cast<int>(version % 1001);
            ParamSnapshot snapshot{version, dry, 1000 - dry};

            // 控制线程允许短暂让出 CPU;它不承担实时音频期限。
            while (!queue.push(snapshot)) {
                std::this_thread::yield();
            }
        }
        producerDone.store(true, std::memory_order_release);
    });

    std::thread audio([&] {
        ParamSnapshot snapshot{};
        while (!producerDone.load(std::memory_order_acquire) ||
               consumed.load(std::memory_order_relaxed) < 50000) {
            // 测试线程在队列空时直接重试;真实回调只尝试读取,不等待数据。
            if (!queue.pop(snapshot)) {
                continue;
            }

            if (snapshot.dryMilli + snapshot.wetMilli != 1000) {
                tornSnapshots.fetch_add(1, std::memory_order_relaxed);
            }
            consumed.fetch_add(1, std::memory_order_relaxed);
        }
    });

    producer.join();
    audio.join();

    std::cout << "consumed=" << consumed.load() << "\n";
    std::cout << "torn=" << tornSnapshots.load() << "\n";
}

编译并运行并发测试:

bash
c++ -std=c++17 -O2 -pthread spsc_params.cpp -o spsc_params
./spsc_params

预期输出:

text
consumed=50000
torn=0

consumed=50000 说明所有快照都被消费,torn=0 说明消费者没有读到 dry/wet 不属于同一快照的中间态。

音频线程通常只需要最新值

真实音频回调往往不需要逐个应用所有历史 UI 更新。用户在一个音频块期间拖动滑杆几十次,下一块开始时只采用当前最新快照通常更合理。做法是在块开始时连续 pop,直到队列为空,只保留最后一次成功读取的快照,然后用它处理整个音频块。

这会把参数切换固定在块边界,避免同一块前半段使用旧参数、后半段使用新参数。对于增益、频率等容易产生 zipper noise 的连续参数,还应在 DSP 内对“上一值 → 新值”做短时间平滑,而不是让控制线程发送更多中间更新。

边界条件必须提前定义

SPSC 只适用于恰好一个生产者和一个消费者。如果多个 UI、MIDI、网络线程都直接调用 push,这个实现就不再满足线程安全前提,应先汇聚到一个控制线程,或改用真正的 MPSC 结构。

队列满时也不要让音频线程等待。参数更新通常可以选择覆盖策略、丢弃旧更新或在生产端重试;事件类消息则要根据业务决定是否允许丢失。无论采用哪种策略,都应把“谁可以阻塞、谁绝不能阻塞”写成接口约束。

最终应保持一个简单规则:独立标量用原子变量,彼此关联的一组参数用不可分割快照,跨线程传递用固定容量无锁通道,音频线程只在明确的块边界接收并应用新状态。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用无锁队列传递控制参数

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通