use std::collections::VecDeque;
use std::io;
use std::sync::{Arc, Mutex};
use windows_threadpool_sys::work::ThreadpoolWork;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Drain {
Idle,
Scheduled,
}
#[derive(Debug)]
pub struct Rejected<T>(pub(crate) T);
struct Queue<T> {
items: VecDeque<T>,
drain: Drain,
closed: bool,
rings: u64,
discarded: u64,
}
struct Shared<T> {
queue: Mutex<Queue<T>>,
}
pub(crate) struct Servicer<T: Send + 'static> {
shared: Arc<Shared<T>>,
work: ThreadpoolWork,
}
impl<T: Send + 'static> Servicer<T> {
pub(crate) fn new<H>(handle: H) -> io::Result<Self>
where
H: Fn(T) + Send + Sync + 'static,
{
let shared = Arc::new(Shared {
queue: Mutex::new(Queue {
items: VecDeque::new(),
drain: Drain::Idle,
closed: false,
rings: 0,
discarded: 0,
}),
});
let queue = Arc::clone(&shared);
let work = ThreadpoolWork::new(move || drain(&queue, &handle), None)?;
Ok(Self { shared, work })
}
pub(crate) fn submit(&self, item: T) -> Result<(), Rejected<T>> {
let ring = {
let mut queue = lock(&self.shared.queue);
if queue.closed {
return Err(Rejected(item));
}
queue.items.push_back(item);
let ring = queue.drain == Drain::Idle;
if ring {
queue.drain = Drain::Scheduled;
queue.rings += 1;
}
ring
};
if ring {
self.work.submit();
}
Ok(())
}
pub(crate) fn shut_down(&self) {
{
let mut queue = lock(&self.shared.queue);
queue.closed = true;
queue.discarded += queue.items.len() as u64;
queue.items.clear();
}
self.work.cancel_pending();
}
pub(crate) fn is_open(&self) -> bool {
!lock(&self.shared.queue).closed
}
pub(crate) fn quiesce(&self) {
self.work.wait();
}
#[cfg(test)]
pub(crate) fn pending(&self) -> usize {
lock(&self.shared.queue).items.len()
}
#[cfg(test)]
pub(crate) fn rings(&self) -> u64 {
lock(&self.shared.queue).rings
}
#[cfg(test)]
pub(crate) fn discarded(&self) -> u64 {
lock(&self.shared.queue).discarded
}
}
impl<T: Send + 'static> Drop for Servicer<T> {
fn drop(&mut self) {
self.shut_down();
}
}
impl<T: Send + 'static> std::fmt::Debug for Servicer<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let queue = lock(&self.shared.queue);
f.debug_struct("Servicer")
.field("pending", &queue.items.len())
.field("drain", &queue.drain)
.field("closed", &queue.closed)
.field("rings", &queue.rings)
.finish_non_exhaustive()
}
}
fn drain<T, H>(shared: &Shared<T>, handle: &H)
where
H: Fn(T),
{
loop {
let next = {
let mut queue = lock(&shared.queue);
match queue.items.pop_front() {
Some(item) => item,
None => {
queue.drain = Drain::Idle;
return;
}
}
};
handle(next);
}
}
fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
mutex.lock().unwrap_or_else(|poison| poison.into_inner())
}
#[cfg(test)]
mod tests;