编码与格式 / 系统课时

数据包队列

数据包队列

本课实现一个可直接用于播放器读包线程与解码线程之间的数据包队列,重点解决多线程并发访问、队列为空时阻塞等待、结束后排空剩余数据,以及退出时立即唤醒的问题。

学习目标

  • 理解数据包队列在读取线程与解码线程之间承担的职责
  • 实现线程安全的入队、阻塞出队、清空、结束和中止操作
  • 明确 finish、abort 与普通清空之间的语义差异

队列需要解决什么问题

读取线程通常比解码线程更接近网络或文件输入,它持续产生 AVPacket;解码线程则按自身速度消费数据。若双方直接共享容器,容易出现数据竞争、空队列忙等和退出时线程无法结束等问题。

一个可用的数据包队列至少要保证三点:入队和出队操作互斥;队列为空时消费者休眠而不是循环占用 CPU;播放器结束或主动退出时,所有等待线程都能被唤醒。

数据包队列的线程协作与状态转换

设计状态与所有权

队列中的每个元素都由队列持有独立引用。调用方入队后可以立即释放原始 AVPacket,消费者取出后负责释放返回的数据包,这样可以避免两个线程同时修改同一对象。

finish 表示生产者不会再写入,但已有数据仍应继续消费;abort 表示播放器正在退出,等待线程应立即停止;flush 只清空缓存,不自动改变结束或中止状态。

完整实现

下面的示例使用 std::deque 保存数据包,使用条件变量阻塞消费者,并通过枚举值区分正常取包、自然结束和强制中止。

cpp
#include <condition_variable>
#include <deque>
#include <iostream>
#include <mutex>
#include <thread>

extern "C" {
#include <libavcodec/packet.h>
}

enum class PopResult {
    Ok,
    Finished,
    Aborted
};

class PacketQueue {
public:
    ~PacketQueue() {
        abort();
        flush();
    }

    bool push(const AVPacket& source) {
        AVPacket* copy = av_packet_clone(&source);
        if (copy == nullptr) {
            return false;
        }

        // 入队时克隆数据包,调用方可立即释放原始对象。
        std::lock_guard<std::mutex> lock(mutex_);
        if (aborted_ || finished_) {
            av_packet_free(&copy);
            return false;
        }

        packets_.push_back(copy);
        readable_.notify_one();
        return true;
    }

    PopResult pop(AVPacket*& output) {
        std::unique_lock<std::mutex> lock(mutex_);
        // 条件谓词同时覆盖数据到达、自然结束和主动退出。
        readable_.wait(lock, [this] {
            return aborted_ || finished_ || !packets_.empty();
        });

        if (aborted_) {
            return PopResult::Aborted;
        }

        if (!packets_.empty()) {
            output = packets_.front();
            packets_.pop_front();
            return PopResult::Ok;
        }

        return PopResult::Finished;
    }

    void finish() {
        // finish 不清空队列,消费者仍可排空已有数据。
        std::lock_guard<std::mutex> lock(mutex_);
        finished_ = true;
        readable_.notify_all();
    }

    void abort() {
        std::lock_guard<std::mutex> lock(mutex_);
        aborted_ = true;
        readable_.notify_all();
    }

    void flush() {
        // 队列持有克隆包,因此必须在清空时逐个释放。
        std::lock_guard<std::mutex> lock(mutex_);
        while (!packets_.empty()) {
            AVPacket* packet = packets_.front();
            packets_.pop_front();
            av_packet_free(&packet);
        }
    }

private:
    std::deque<AVPacket*> packets_;
    std::mutex mutex_;
    std::condition_variable readable_;
    bool finished_ = false;
    bool aborted_ = false;
};

int main() {
    PacketQueue queue;

    std::thread consumer([&queue] {
        while (true) {
            AVPacket* packet = nullptr;
            PopResult result = queue.pop(packet);

            if (result == PopResult::Ok) {
                std::cout << "consume packet " << packet->stream_index << '\n';
                av_packet_free(&packet);
                continue;
            }

            std::cout << (result == PopResult::Finished
                              ? "queue finished"
                              : "queue aborted")
                      << '\n';
            break;
        }
    });

    std::thread producer([&queue] {
        for (int index = 1; index <= 3; ++index) {
            AVPacket* packet = av_packet_alloc();
            if (packet == nullptr) {
                queue.abort();
                return;
            }

            packet->stream_index = index;
            if (!queue.push(*packet)) {
                av_packet_free(&packet);
                queue.abort();
                return;
            }
            av_packet_free(&packet);
        }
        queue.finish();
    });

    producer.join();
    consumer.join();
    return 0;
}

编译并运行:

bash
g++ -std=c++17 packet_queue.cpp -o packet_queue $(pkg-config --cflags --libs libavcodec libavutil) -pthread
./packet_queue

预期输出:

text
consume packet 1
consume packet 2
consume packet 3
queue finished

关键边界

pop 的判断顺序很重要:先处理 abort,再读取队列,最后判断 finish。这样主动退出时不会继续解码旧数据,而正常结束时又能把已经缓存的数据包全部处理完。

实际播放器还应增加最大缓存大小或总字节数,防止网络读取速度长期高于解码速度。发生跳转时通常先暂停生产者,再 flush,随后重新写入新位置的数据包。

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

目录与阅读设置

阅读设置

17

记录一个想法

数据包队列

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

登录哪都通