#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

// 全局共享资源（模拟任务队列）
std::queue<int> task_queue;
// 互斥锁：保护共享资源和条件判断
std::mutex mtx;
// 条件变量：用于线程间同步
std::condition_variable cv;
// 停止标志：控制线程退出
bool stop_flag = false;

// 消费者线程（等待任务并执行）
void consumer() {
    while (true) {
        // 必须用unique_lock（条件变量需要解锁/加锁的灵活性）
        std::unique_lock<std::mutex> lock(mtx);
        
        // 等待条件满足：队列非空 或 停止标志为true
        // 注意：必须用while循环（防止虚假唤醒）
        cv.wait(lock, []() { 
            return !task_queue.empty() || stop_flag; 
        });

        // 检查是否需要退出
        if (stop_flag && task_queue.empty()) {
            std::cout << "消费者线程退出" << std::endl;
            break;
        }

        // 执行任务（取出队列元素）
        int task = task_queue.front();
        task_queue.pop();
        lock.unlock(); // 解锁，让生产者可以继续生产（非必须，但能提升性能）

        std::cout << "处理任务：" << task << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟任务耗时
    }
}

// 生产者线程（生产任务并唤醒消费者）
void producer() {
    for (int i = 1; i <= 5; ++i) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            task_queue.push(i);
            std::cout << "生产任务：" << i << std::endl;
        } // 手动解锁，避免唤醒时还持有锁

        // 唤醒一个等待的消费者线程
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }

    // 生产完毕，设置停止标志并唤醒所有消费者
    {
        std::lock_guard<std::mutex> lock(mtx);
        stop_flag = true;
    }
    cv.notify_all();
}

int main() {
    std::thread consumer_thread(consumer);
    std::thread producer_thread(producer);

    consumer_thread.join();
    producer_thread.join();

    return 0;
}

int MpFileManager::workerThread()
{
    std::unique_lock<std::mutex> lock(mutex);
    is_run.store(true);
    while (is_run.load()) {
        queueCondition_.wait_for(lock, std::chrono::seconds(2), [this] {
            return !is_run.load() || work_start.load(); });
        if (!is_run.load())
            break;

        lock.lock();
    }
}