use std::io;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread::JoinHandle;
use std::time::Duration;
use mio::Waker;
use crate::handle::ResponseHandle;
#[derive(Debug)]
pub(crate) struct ThreadHandle {
is_owner: bool,
is_alive: Arc<AtomicBool>,
should_die: Arc<AtomicBool>,
exited: ResponseHandle<()>,
handle: Option<JoinHandle<()>>,
waker: Option<Arc<Waker>>,
}
impl ThreadHandle {
pub fn new() -> Self {
Self {
is_owner: true,
is_alive: Arc::new(AtomicBool::new(true)),
should_die: Arc::new(AtomicBool::new(false)),
exited: ResponseHandle::new(),
handle: None,
waker: None,
}
}
pub fn set_handle(&mut self, handle: JoinHandle<()>) {
self.handle = Some(handle);
}
pub fn set_waker(&mut self, waker: Arc<Waker>) {
self.waker = Some(waker);
}
pub fn wake(&self) -> io::Result<()> {
match &self.waker {
Some(w) => w.wake(),
None => Ok(()),
}
}
pub fn is_alive(&self) -> bool {
self.is_alive.load(Ordering::Relaxed)
}
pub fn should_live(&self) -> bool {
!self.should_die.load(Ordering::Relaxed)
}
pub fn has_died(&self) {
self.is_alive.store(false, Ordering::Relaxed);
self.exited.fulfill(Ok(()));
}
pub fn wait_exited(&self, timeout: Duration) -> bool {
self.exited.wait_timeout(timeout).is_ok()
}
pub fn request_stop(&self) {
self.should_die.store(true, Ordering::Relaxed);
let _ = self.wake();
}
pub fn to_pass_in(&self) -> Self {
Self {
is_owner: false,
is_alive: self.is_alive.clone(),
should_die: self.should_die.clone(),
exited: self.exited.clone(),
handle: None,
waker: self.waker.clone(),
}
}
}
pub(crate) struct ExitGuard(pub(crate) ThreadHandle);
impl Drop for ExitGuard {
fn drop(&mut self) {
self.0.has_died();
}
}
impl Drop for ThreadHandle {
fn drop(&mut self) {
if !self.is_owner {
return;
}
self.should_die.store(true, Ordering::Relaxed);
let _ = self.wake();
if let Some(handle) = self.handle.take() {
let _ = handle.join();
}
}
}