c++ - 如果有足够多的事件，boost::mutex 可以锁定操作系统吗？

Question

我正在使用中间处理线程处理生产者消费者问题。当我运行 200 个这样的应用程序时，它会在大量连接超时时将系统锁定在 win7 中。不幸的是，不是以我知道如何调试它的方式。系统变得无响应，我必须使用电源按钮重新启动它。它在我的 Mac 上运行良好，奇怪的是，它在安全模式下在 Windows 中运行良好。

我使用的是 boost 1.44，因为这是主机应用程序使用的。

这是我的队列。我的意图是队列的大小是同步的。我对此进行了操作以使用 timed_wait 来确保我没有丢失通知，尽管我没有看到效果上的差异。

class ConcurrentQueue {
public:
    void push(const std::string& str, size_t notify_size, size_t max_size);
    std::string pop();

private:
    std::queue<std::string> queue;
    boost::mutex mutex;
    boost::condition_variable cond;
};

void ConcurrentQueue::push(
  const std::string& str, size_t notify_size, size_t max_size) {
    size_t queue_size;
    {{
        boost::mutex::scoped_lock lock(mutex);
        if (queue.size() < max_size) {
            queue.push(str);
        }
        queue_size = queue.size();
    }}
    if (queue_size >= notify_size)
        cond.notify_one();
}

std::string ConcurrentQueue::pop() {
    boost::mutex::scoped_lock lock(mutex);
    while (!queue.size())
        cond.wait(lock);
    std::string str = queue.front();
    queue.pop();
    return str;
}

这些线程使用以下队列使用 libcurl 进行处理和发送。

boost::shared_ptr<ConcurrentQueue> queue_a(new ConcurrentQueue);
boost::shared_ptr<ConcurrentQueue> queue_b(new ConcurrentQueue);

void prod_run(size_t iterations) {
    try {
        // stagger startup
        boost::this_thread::sleep(
              boost::posix_time::seconds(random_num(0, 25)));
        size_t save_frequency = random_num(41, 97);
        for (size_t i = 0; i < iterations; i++) {
            // compute
            size_t v = 1;
            for (size_t j = 2; j < (i % 7890) + 4567; j++) {
                v *= j;
                v = std::max(v % 39484, v % 85783);
            }
            // save
            if (i % save_frequency == 0) {
                std::string iv = 
                              boost::str( boost::format("%1%=%2%") % i % v );
                queue_a->push(iv, 1, 200);
            }
            sleep_frame();
        }
    } catch (boost::thread_interrupted&) {
    }
}

void prodcons_run() {
    try {
        for (;;) {
            std::string iv = queue_a->pop();
            queue_b->push(iv, 1, 200);
        }
    } catch (boost::thread_interrupted&) {
    }
}

void cons_run() {
    try {
        for (;;) {
            std::string iv = queue_b->pop();
            send_http_post("http://127.0.0.1", iv);
        }
    } catch (boost::thread_interrupted&) {
    }
}

我对以这种方式使用互斥量的理解应该不会使系统无响应。如果有的话，我的应用程序会死锁并永远休眠。

有没有什么方法可以同时拥有 200 个这样的场景，而不是这种情况？

更新:

当我重新启动计算机时，大多数时候我需要重新插入 USB 键盘才能让它响应。鉴于司机的评论，我认为这可能是相关的。我尝试更新北桥驱动程序，尽管它们是最新的。我会看看是否还有其他需要注意的驱动程序。

更新:

我观察过内存、非分页池、cpu、句柄、端口，在系统响应时，它们在任何时候都没有达到惊人的速度。可能最后会出现尖峰，但我看不到。

更新:

当系统挂起时，它停止渲染并且不响应键盘。它渲染的最后一帧仍然存在。系统听起来好像仍在运行，当系统重新启动时，事件查看器中没有任何内容表明它崩溃了。也没有故障转储文件。我将此解释为操作系统被阻止执行。

Answer 1

互斥锁会锁定使用同一锁的其他应用程序。操作系统使用的任何互斥体都不应该(直接)对任何应用程序可用。

当然，如果以某种方式使用操作系统实现互斥锁，它可能会调用操作系统，从而占用 CPU 资源。但是，互斥锁不应该导致比应用程序以任何其他方式使用 CPU 资源更糟糕的行为。

当然，如果您以不适当的方式使用锁，应用程序的不同部分可能会陷入死锁，因为函数 1 获取锁 A，然后函数 2 获取锁 B。如果函数 1 尝试获取锁 B , 并且函数 2 在释放它们各自的锁之前尝试获取锁 A，你有一个死锁。这里的技巧是总是以相同的顺序获取多个锁。所以如果同时需要两把锁，总是先获取锁A，再获取锁B。

死锁不应该影响操作系统本身——如果有的话，它会让它变得更好，但如果应用程序在死锁的情况下以某种方式“行为不端”，它可能会通过调用操作系统很多而导致问题——例如，如果锁定是通过以下方式完成的:

while (!trylock(lock))
{
      /// do nothing here
}

它可能会导致系统使用高峰。