std::condition_variable的简单demo

以下是一个使用std::condition_variable的简单示例代码：

#include <iostream>
#include <thread>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker_thread()
{
    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // 工作完成后通知主线程
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
}

int main()
{
    std::thread worker(worker_thread);
    
    // 等待工作完成
    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return ready; });
    }
    
    std::cout << "工作已完成！" << std::endl;
    
    worker.join();
    
    return 0;
}

相关问题

多线程 中lock_guard<mutex>lock 图像指针队列 demo

在多线程编程中，`std::lock_guard<std::mutex>` 是一种智能锁，它是一种简化版的互斥锁管理方式。当你需要保护一段代码不被并发访问时，可以使用 `lock_guard`，它会在构造时自动获取锁，在析构时自动释放锁，无需手动调用 lock 和 unlock 函数，这有助于避免忘记解锁导致的资源泄露问题。

图像指针队列（Image Pointer Queue，IPQ）是一个数据结构，通常用于存储图片指针，并按照某种策略进行组织，如先进先出（FIFO）、最近最少使用（LRU）等。在多线程环境中，可能会有一个单独的线程负责从 IPQ 中取出图片指针供其他线程使用，同时使用 `lock_guard` 确保对队列的操作是线程安全的。

下面是一个简单的 C++ 示例，展示如何使用 `std::lock_guard` 保护图像指针队列：

#include <queue>
#include <mutex>
#include <condition_variable>

class Image {
public:
    // 图片数据...
};

class ImageQueue {
private:
    std::queue<Image*> images;
    mutable std::mutex queue_mutex;
    std::condition_variable image_available;

public:
    void push(Image* img) {
        std::lock_guard<std::mutex> lock(queue_mutex);
        images.push(img);
        image_available.notify_one(); // 当有新元素入队时唤醒等待者
    }

    Image* pop() {
        std::unique_lock<std::mutex> lock(queue_mutex);
        image_available.wait(lock, [] { return !images.empty(); }); // 阻塞直到队列非空
        if (images.empty()) {
            throw std::runtime_error("Queue is empty");
        }
        Image* img = images.front();
        images.pop();
        return img;
    }
};

int main() {
    ImageQueue queue;
    // 创建和添加图片实例
    Image img1, img2;
    queue.push(&img1); // 使用lock_guard确保操作线程安全

    // 两个线程分别从队列取图
    std::thread thread1([](ImageQueue& q) {
        while (true) {
            try {
                Image* img = q.pop();
                // 处理图片...
            } catch (const std::exception& e) {
                break; // 如果队列为空则退出循环
            }
        }
    }, std::ref(queue));

    std::thread thread2([](ImageQueue& q) {
        while (true) {
            q.push(&img2); // 同样使用lock_guard
            // 模拟处理延迟...
        }
    }, std::ref(queue));

    thread1.join();
    thread2.join();

    return 0;
}

在这个例子中，`push` 和 `pop` 方法都使用了 `lock_guard` 来保证队列操作的原子性和互斥性。当线程1和线程2同时试图访问队列时，只有一个线程会被允许执行相应操作，另一个线程将阻塞直到前一个完成。

C++ 进程同步demo

在C++中，进程同步通常通过互斥锁（mutex）、条件变量（condition_variable）或者信号量（semaphore）等工具来实现。这里提供一个简单的基于互斥锁的线程同步示例：

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // 创建一个互斥锁

void printNumber(int number, bool isSecondThread) {
    std::lock_guard<std::mutex> lock(mtx); // 获取锁，防止并发修改共享资源
    if (isSecondThread) {
        std::cout << "Second thread: Waiting for first thread to finish..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟任务延迟
    }
    std::cout << "Thread " << (isSecondThread ? "2" : "1") << ": Printing number " << number << std::endl;
}

int main() {
    std::thread t1(printNumber, 10, false); // 第一号线程
    std::thread t2(printNumber, 20, true); // 第二线程，等待第一线程完成后打印

    t1.join(); // 等待主线程结束
    t2.join(); // 等待所有线程结束

    return 0;
}

在这个例子中，两个线程分别打印数字。`printNumber`函数会获取互斥锁，确保同一时间只有一个线程可以进入临界区。如果第二个线程启动时第一个线程还在运行，它会选择等待。