Dining Philosophers

The dining philosophers problem is a classic problem in concurrency:

Five philosophers dine together at the same table. Each philosopher has their own place at the table. There is a fork between each plate. The dish served is a kind of spaghetti which has to be eaten with two forks. Each philosopher can only alternately think and eat. Moreover, a philosopher can only eat their spaghetti when they have both a left and right fork. Thus two forks will only be available when their two nearest neighbors are thinking, not eating. After an individual philosopher finishes eating, they will put down both forks.

You will need a local Cargo installation for this exercise. Copy the code below to src/main.rs file, fill out the blanks, and test that cargo run does not deadlock:

  1. use std::sync::mpsc;
  2. use std::sync::{Arc, Mutex};
  3. use std::thread;
  4. use std::time::Duration;
  6. struct Fork;
  8. struct Philosopher {
  9.     name: String,
  10.     // left_fork: ...
  11.     // right_fork: ...
  12.     // thoughts: ...
  13. }
  15. impl Philosopher {
  16.     fn think(&self) {
  17.         self.thoughts
  18.             .send(format!("Eureka! {} has a new idea!", &self.name))
  19.             .unwrap();
  20.     }
  22.     fn eat(&self) {
  23.         // Pick up forks...
  24.         println!("{} is eating...", &self.name);
  25.         thread::sleep(Duration::from_millis(10));
  26.     }
  27. }
  29. static PHILOSOPHERS: &[&str] =
  30.     &["Socrates", "Plato", "Aristotle", "Thales", "Pythagoras"];
  32. fn main() {
  33.     // Create forks
  35.     // Create philosophers
  37.     // Make them think and eat
  39.     // Output their thoughts
  40. }