上个赛季前面那

// SharedQueue.h
#include
#include
#include <condition_variable>
#include

template
class SharedQueue {
public:
// 添加元素
void push(const T& item) {
std::lock_guardstd::mutex lock(mtx);
queue.push(item);
cv.notify_one();
}

// 从队列中取一个元素
bool pop(T& item) {
    std::lock_guard<std::mutex> lock(mtx);
    if (queue.empty()) return false;
    item = queue.front();
    queue.pop();
    return true;
}

// 新增方法：查看队列中的最后n个元素
size_t peekLastN(std::vector<T>& items, size_t n) {
    std::lock_guard<std::mutex> lock(mtx);
    size_t count = 0;
    std::queue<T> tempQueue = queue;  // 使用临时队列来不改变原队列

    // 获取最后n个元素
    std::vector<T> reversedItems;
    while (!tempQueue.empty() && reversedItems.size() < n) {
        reversedItems.push_back(tempQueue.back());
        tempQueue.pop();
    }

    // 将元素反转回来，保证顺序正确
    std::reverse(reversedItems.begin(), reversedItems.end());

    // 将结果存入传入的vector
    items.insert(items.end(), reversedItems.begin(), reversedItems.end());
    
    return reversedItems.size();
}

bool isEmpty() const {
    std::lock_guard<std::mutex> lock(mtx);
    return queue.empty();
}

private:
std::queue queue;
mutable std::mutex mtx;
std::condition_variable cv;
};
// QueueProcessor.h
#include “SharedQueue.h”
#include “DatabaseHandler.h”
#include
#include
#include

template
class QueueProcessor {
public:
QueueProcessor(SharedQueue& queue, const std::string& dbName)
: queue(queue), databaseName(dbName), stopFlag(false), writeFinished(false) {}

void start() {
    workerThread = std::thread(&QueueProcessor::processQueue, this);
}

void stop() {
    stopFlag.store(true);
    if (workerThread.joinable()) workerThread.join();
}

bool isWriteFinished() const {
    return writeFinished.load();
}

private:
SharedQueue& queue;
std::string databaseName;
std::atomic stopFlag;
std::atomic writeFinished;
std::thread workerThread;

void processQueue() {
    DatabaseHandler<T>& handler = DatabaseHandler<T>::getInstance();
    std::vector<T> dataBatch;
    size_t batchSize = 10; // 每次处理10个元素，可根据需要调整

    while (!stopFlag.load()) {
        dataBatch.clear();
        size_t extracted = queue.peekLastN(dataBatch, batchSize);

        if (extracted > 0) {
            handler.writeBatch(dataBatch, databaseName);
            writeFinished.store(true);  // 假设写入完成
        } else {
            writeFinished.store(false);  // 如果没有数据可写
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(500));  // 调整处理频率
    }
}

};