UGC NET CS 2014 年 12 月 – III 问题 66

介绍

UGC NET CS 2014 年 12 月 – III 问题 66 是一道涉及 C++ 和多线程的问题，要求程序员实现一个生产者-消费者模型。

题目描述

要求使用 C++ 编写程序，实现一个生产者-消费者模型。模型包括以下要素：

• 一个缓存区，可以存储 N 个元素。
• 一个生产者线程，每隔 T1 秒向缓存区中加入一个元素。
• 一个消费者线程，每隔 T2 秒从缓存区中取出一个元素。
• 当缓存区满时，生产者线程应该等待；当缓存区空时，消费者线程应该等待。
• 程序应该实现对缓存区的互斥访问。

要求程序必须使用以下函数：

void producer(int val); // 将 val 写入缓存区
int consumer(); // 从缓存区中取出一个元素

分析

本题需要实现一个生产者-消费者模型，要求使用 C++ 编写程序，实现以下功能：

• 生产者线程：每隔 T1 秒向缓存区中加入一个元素。
• 消费者线程：每隔 T2 秒从缓存区中取出一个元素。
• 缓存区：可以存储 N 个元素。
• 缓存区互斥访问。
• 当缓存区满时，生产者线程应该等待；当缓存区空时，消费者线程应该等待。

这可以通过使用 C++ 的线程库和锁实现。

在 C++ 中，可以使用 std::thread 类来创建线程。该类需要一个函数指针作为参数，并在新线程中运行该函数。

要实现缓存区的互斥访问，可以使用 std::mutex 类创建一个锁，然后使用 std::lock_guard 类保持锁定状态。

代码实现

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

const int N = 10;
const int T1 = 1;
const int T2 = 2;

std::queue<int> data_queue;
std::mutex m;

void producer() {
    int i = 0;
    while (i < 20) {
        std::this_thread::sleep_for(std::chrono::seconds(T1));
        int val = rand() % 100;
        {
            std::lock_guard<std::mutex> lock(m);
            if (data_queue.size() < N) {
                data_queue.push(val);
                std::cout << "producer write " << val << " to data_queue" << std::endl;
                ++i;
            } else {
                std::cout << "data_queue is full, producer wait" << std::endl;
            }
        }
    }
}

void consumer() {
    int i = 0;
    while (i < 20) {
        std::this_thread::sleep_for(std::chrono::seconds(T2));
        {
            std::lock_guard<std::mutex> lock(m);
            if (!data_queue.empty()) {
                int val = data_queue.front();
                data_queue.pop();
                std::cout << "consumer read " << val << " from data_queue" << std::endl;
                ++i;
            } else {
                std::cout << "data_queue is empty, consumer wait" << std::endl;
            }
        }
    }
}

int main() {
    std::thread tproducer(producer);
    std::thread tconsumer(consumer);

    tproducer.join();
    tconsumer.join();

    return 0;
}

以上是一个完整的 C++ 程序，实现了生产者-消费者模型，并满足 UGC NET CS 2014 年 12 月 – III 问题 66 的要求。

总结

本题要求程序员实现一个生产者-消费者模型，要求使用 C++ 编写程序，实现对缓存区的互斥访问。这可以通过使用 C++ 的线程库和锁实现。

程序使用 std::thread 类创建两个线程，一个负责生产，另一个负责消费，使用 std::queue 类实现缓存区，使用 std::mutex 类创建锁，使用 std::lock_guard 类保持锁定状态，实现缓存区的互斥访问。

在实现缓存区满和空时的等待时，可以使用 std::this_thread::sleep_for 函数实现线程的等待。注意要使用 std::lock_guard 对锁进行保护后再进行条件检查。