Dining Philosophers —- Async

See dining philosophers for a description of the problem.

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

  1. use std::sync::Arc;
  2. use tokio::sync::{mpsc, Mutex};
  3. use tokio::time;
  5. struct Fork;
  7. struct Philosopher {
  8.     name: String,
  9.     // left_fork: ...
  10.     // right_fork: ...
  11.     // thoughts: ...
  12. }
  14. impl Philosopher {
  15.     async fn think(&self) {
  16.         self.thoughts
  17.             .send(format!("Eureka! {} has a new idea!", &self.name))
  18.             .await
  19.             .unwrap();
  20.     }
  22.     async fn eat(&self) {
  23.         // Keep trying until we have both forks
  24.         println!("{} is eating...", &self.name);
  25.         time::sleep(time::Duration::from_millis(5)).await;
  26.     }
  27. }
  29. static PHILOSOPHERS: &[&str] =
  30.     &["Socrates", "Hypatia", "Plato", "Aristotle", "Pythagoras"];
  32. #[tokio::main]
  33. async fn main() {
  34.     // Create forks
  36.     // Create philosophers
  38.     // Make them think and eat
  40.     // Output their thoughts
  41. }

Since this time you are using Async Rust, you’ll need a tokio dependency. You can use the following Cargo.toml:

  1. [package]
  2. name = "dining-philosophers-async-dine"
  3. version = "0.1.0"
  4. edition = "2021"
  6. [dependencies]
  7. tokio = { version = "1.26.0", features = ["sync", "time", "macros", "rt-multi-thread"] }

Also note that this time you have to use the Mutex and the mpsc module from the tokio crate.

This slide should take about 20 minutes.

  • Can you make your implementation single-threaded?