模拟有五个哲学家的哲学家进餐问题。c++

以下是使用 C++11 中的 std::mutex 和 std::thread 实现的哲学家进餐问题示例代码：

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

const int kNumPhilosophers = 5;

class Philosopher {
 public:
  Philosopher(int id, std::mutex& left_fork, std::mutex& right_fork)
      : id_(id), left_fork_(left_fork), right_fork_(right_fork) {}

  void operator()() {
    while (true) {
      // 先获取左边的叉子，再获取右边的叉子
      std::unique_lock<std::mutex> left_lock(left_fork_);
      std::unique_lock<std::mutex> right_lock(right_fork_);
      std::cout << "Philosopher " << id_ << " is eating." << std::endl;
      // 模拟进餐过程
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      std::cout << "Philosopher " << id_ << " is done eating." << std::endl;
    }
  }

 private:
  int id_;
  std::mutex& left_fork_;
  std::mutex& right_fork_;
};

int main() {
  // 创建 5 把叉子
  std::mutex forks[kNumPhilosophers];
  // 创建 5 个哲学家
  Philosopher philosophers[kNumPhilosophers] = {
      {0, forks[0], forks[1]},
      {1, forks[1], forks[2]},
      {2, forks[2], forks[3]},
      {3, forks[3], forks[4]},
      {4, forks[4], forks[0]}};

  // 启动 5 个线程，分别代表 5 个哲学家
  std::thread threads[kNumPhilosophers];
  for (int i = 0; i < kNumPhilosophers; ++i) {
    threads[i] = std::thread(philosophers[i]);
  }

  // 等待所有线程结束
  for (int i = 0; i < kNumPhilosophers; ++i) {
    threads[i].join();
  }

  return 0;
}

在上面的代码中，每个哲学家都是一个函数对象，它需要获取左右两把叉子才能进餐。我们使用 std::mutex 类来实现互斥访问。当一个哲学家想要进餐时，它首先尝试获取左边的叉子，如果成功获取，则尝试获取右边的叉子；如果右边的叉子已经被其他哲学家占用，则先释放左边的叉子，等待一段时间再重新尝试。当一个哲学家成功获取到左右两把叉子时，它就可以进餐了，然后释放叉子。

需要注意的是，由于每个哲学家都是一个线程，因此它们的执行顺序是不确定的，可能会出现死锁或者饥饿的情况。为了避免这种情况，我们可以使用一些调度算法来确保每个哲学家都能够公平地获得资源。