use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Condvar, Mutex, MutexGuard};
use std::time::{Duration, Instant};
use tokio::sync::Notify;
use tokio::sync::futures::Notified;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum WaitOutcome {
Signalled,
Closed,
TimedOut,
}
impl WaitOutcome {
#[must_use]
pub const fn may_continue(self) -> bool {
!matches!(self, Self::Closed)
}
}
#[derive(Debug, Default)]
struct Ticket {
value: u64,
}
#[derive(Debug)]
pub struct Signal {
ticket: Mutex<Ticket>,
condvar: Condvar,
notify: Notify,
ticket_gauge: AtomicU64,
closed: AtomicBool,
}
impl Default for Signal {
fn default() -> Self {
Self::new()
}
}
impl Signal {
#[must_use]
pub fn new() -> Self {
Self {
ticket: Mutex::new(Ticket::default()),
condvar: Condvar::new(),
notify: Notify::new(),
ticket_gauge: AtomicU64::new(0),
closed: AtomicBool::new(false),
}
}
#[must_use]
pub fn ticket(&self) -> u64 {
self.ticket_gauge.load(Ordering::Acquire)
}
#[must_use]
pub fn is_closed(&self) -> bool {
self.closed.load(Ordering::Acquire)
}
pub fn notify(&self) {
{
let mut ticket = lock(&self.ticket);
ticket.value = ticket.value.wrapping_add(1);
self.ticket_gauge.store(ticket.value, Ordering::Release);
}
self.condvar.notify_all();
self.notify.notify_waiters();
}
pub fn close(&self) {
self.closed.store(true, Ordering::Release);
self.notify();
}
pub fn notified(&self) -> Notified<'_> {
self.notify.notified()
}
#[must_use]
pub fn wait_blocking(&self, since: u64, timeout: Option<Duration>) -> WaitOutcome {
let deadline = timeout.map(|timeout| Instant::now() + timeout);
let mut ticket = lock(&self.ticket);
loop {
if self.closed.load(Ordering::Acquire) {
return WaitOutcome::Closed;
}
if ticket.value != since {
return WaitOutcome::Signalled;
}
match deadline {
None => {
ticket = self
.condvar
.wait(ticket)
.unwrap_or_else(std::sync::PoisonError::into_inner);
}
Some(deadline) => {
let Some(remaining) = deadline.checked_duration_since(Instant::now()) else {
return WaitOutcome::TimedOut;
};
let (guard, result) = self
.condvar
.wait_timeout(ticket, remaining)
.unwrap_or_else(std::sync::PoisonError::into_inner);
ticket = guard;
if result.timed_out()
&& ticket.value == since
&& !self.closed.load(Ordering::Acquire)
{
return WaitOutcome::TimedOut;
}
}
}
}
}
pub async fn wait_async(&self) -> WaitOutcome {
if self.is_closed() {
return WaitOutcome::Closed;
}
let notified = self.notified();
if self.is_closed() {
return WaitOutcome::Closed;
}
notified.await;
if self.is_closed() {
WaitOutcome::Closed
} else {
WaitOutcome::Signalled
}
}
}
fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
mutex
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use std::sync::Arc;
#[test]
fn a_notification_before_the_wait_is_not_lost() {
let signal = Signal::new();
let ticket = signal.ticket();
signal.notify();
assert_eq!(
signal.wait_blocking(ticket, Some(Duration::from_millis(50))),
WaitOutcome::Signalled,
"the ticket remembers the notification"
);
}
#[test]
fn a_wait_times_out_when_nothing_happens() {
let signal = Signal::new();
let ticket = signal.ticket();
let start = Instant::now();
assert_eq!(
signal.wait_blocking(ticket, Some(Duration::from_millis(20))),
WaitOutcome::TimedOut
);
assert!(start.elapsed() >= Duration::from_millis(15));
}
#[test]
fn a_blocking_waiter_is_woken_by_another_thread() {
let signal = Arc::new(Signal::new());
let ticket = signal.ticket();
let producer = Arc::clone(&signal);
let handle = std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(10));
producer.notify();
});
assert_eq!(
signal.wait_blocking(ticket, Some(Duration::from_secs(5))),
WaitOutcome::Signalled
);
handle.join().unwrap();
}
#[test]
fn closing_wakes_everybody_and_is_terminal() {
let signal = Arc::new(Signal::new());
assert!(!signal.is_closed());
let waiters: Vec<_> = (0..4)
.map(|_| {
let signal = Arc::clone(&signal);
let ticket = signal.ticket();
std::thread::spawn(move || {
signal.wait_blocking(ticket, Some(Duration::from_secs(5)))
})
})
.collect();
std::thread::sleep(Duration::from_millis(10));
signal.close();
for waiter in waiters {
assert_eq!(waiter.join().unwrap(), WaitOutcome::Closed);
}
assert!(signal.is_closed());
signal.close();
assert_eq!(
signal.wait_blocking(signal.ticket(), None),
WaitOutcome::Closed
);
}
#[test]
fn the_ticket_advances_once_per_notification() {
let signal = Signal::new();
let first = signal.ticket();
signal.notify();
let second = signal.ticket();
signal.notify();
assert_eq!(second, first.wrapping_add(1));
assert_eq!(signal.ticket(), first.wrapping_add(2));
}
#[test]
fn wait_outcomes_classify_continuation() {
assert!(WaitOutcome::Signalled.may_continue());
assert!(WaitOutcome::TimedOut.may_continue());
assert!(!WaitOutcome::Closed.may_continue());
}
#[test]
fn a_poisoned_lock_does_not_wedge_the_signal() {
let signal = Arc::new(Signal::new());
let poisoner = Arc::clone(&signal);
let handle = std::thread::spawn(move || {
let _guard = lock(&poisoner.ticket);
panic!("simulated panic while holding the ticket lock");
});
assert!(handle.join().is_err());
let ticket = signal.ticket();
signal.notify();
assert_eq!(
signal.wait_blocking(ticket, Some(Duration::from_millis(50))),
WaitOutcome::Signalled
);
}
#[tokio::test]
async fn an_async_waiter_is_woken() {
let signal = Arc::new(Signal::new());
let producer = Arc::clone(&signal);
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(5)).await;
producer.notify();
});
assert_eq!(signal.wait_async().await, WaitOutcome::Signalled);
}
#[tokio::test]
async fn an_async_waiter_sees_a_close() {
let signal = Arc::new(Signal::new());
let producer = Arc::clone(&signal);
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(5)).await;
producer.close();
});
assert_eq!(signal.wait_async().await, WaitOutcome::Closed);
assert_eq!(signal.wait_async().await, WaitOutcome::Closed);
}
#[tokio::test]
async fn the_notified_future_is_created_before_the_check() {
let signal = Signal::new();
let notified = signal.notified();
signal.notify();
notified.await;
}
}