1 files changed, 77 insertions, 0 deletions
diff --git a/examples/happylock.rs b/examples/happylock.rs
new file mode 100755
index 0000000..4ebc2f3
--- /dev/null
+++ b/examples/happylock.rs
@@ -0,0 +1,77 @@
+use std::{thread, time::Duration};
+
+use happylock::{collection, ThreadKey};
+
+type Mutex<T> = happylock::mutex::Mutex<T, sys_locks::Mutex>;
+
+static PHILOSOPHERS: [Philosopher; 5] = [
+	Philosopher {
+		name: "Socrates",
+		left: 0,
+		right: 1,
+	},
+	Philosopher {
+		name: "John Rawls",
+		left: 1,
+		right: 2,
+	},
+	Philosopher {
+		name: "Jeremy Bentham",
+		left: 2,
+		right: 3,
+	},
+	Philosopher {
+		name: "John Stuart Mill",
+		left: 3,
+		right: 4,
+	},
+	Philosopher {
+		name: "Judith Butler",
+		left: 4,
+		right: 0,
+	},
+];
+
+static FORKS: [Mutex<()>; 5] = [
+	Mutex::new(()),
+	Mutex::new(()),
+	Mutex::new(()),
+	Mutex::new(()),
+	Mutex::new(()),
+];
+
+struct Philosopher {
+	name: &'static str,
+	left: usize,
+	right: usize,
+}
+
+impl Philosopher {
+	fn cycle(&self) {
+		let key = ThreadKey::get().unwrap();
+		thread::sleep(Duration::from_secs(1));
+
+		// safety: no philosopher asks for the same fork twice
+		let forks = [&FORKS[self.left], &FORKS[self.right]];
+		let forks = unsafe { collection::RefLockCollection::new_unchecked(&forks) };
+		let forks = forks.lock(key);
+		println!("{} is eating...", self.name);
+		thread::sleep(Duration::from_secs(1));
+		println!("{} is done eating", self.name);
+		drop(forks);
+	}
+}
+
+fn main() {
+	let handles: Vec<_> = PHILOSOPHERS
+		.iter()
+		.map(|philosopher| thread::spawn(move || philosopher.cycle()))
+		// The `collect` is absolutely necessary, because we're using lazy
+		// iterators. If `collect` isn't used, then the thread won't spawn
+		// until we try to join on it.
+		.collect();
+
+	for handle in handles {
+		_ = handle.join();
+	}
+}