pub struct Waker { /* private fields */ }Expand description
Waker allows cross-thread waking of Poll.
When created it will cause events with readable readiness and the
provided token if wake is called, possibly from another thread.
Notes
Waker events are only guaranteed to be delivered while the Waker value
is alive.
Only a single Waker can be active per Poll, if multiple threads need
access to the Waker it can be shared via for example an Arc. What
happens if multiple Wakers are registered with the same Poll is
unspecified.
Implementation notes
On platforms that support kqueue this will use the EVFILT_USER event
filter, see implementation notes of Poll to see what platforms support
kqueue. On Linux it uses eventfd.
Examples
Wake a Poll instance from another thread.
use std::thread;
use std::time::Duration;
use std::sync::Arc;
use mio::{Events, Token, Poll, Waker};
const WAKE_TOKEN: Token = Token(10);
let mut poll = Poll::new()?;
let mut events = Events::with_capacity(2);
let waker = Arc::new(Waker::new(poll.registry(), WAKE_TOKEN)?);
// We need to keep the Waker alive, so we'll create a clone for the
// thread we create below.
let waker1 = waker.clone();
let handle = thread::spawn(move || {
// Working hard, or hardly working?
thread::sleep(Duration::from_millis(500));
// Now we'll wake the queue on the other thread.
waker1.wake().expect("unable to wake");
});
// On our current thread we'll poll for events, without a timeout.
poll.poll(&mut events, None)?;
// After about 500 milliseconds we should be awoken by the other thread and
// get a single event.
assert!(!events.is_empty());
let waker_event = events.iter().next().unwrap();
assert!(waker_event.is_readable());
assert_eq!(waker_event.token(), WAKE_TOKEN);