Timeouts for synchronization primitives

[johannescpk]

lock_api has those interesting traits that allow you to specify a timeout for sync primitives when trying to acquire a lock, such as RawRwLockTimed. This proves especially useful in cases where you want to handle deadlocks differently than just having your program fully hang up.

Not sure if it's at all feasible/possible for tokio to add such features? But I'd find them useful for sure. If they're generally possible I'd also gladly take pointers on how the implementation could be approached.

[carllerche]

With async, you can add a timeout to any operation without an explicit API by using the timeout function.

so, you would do something like:

time::timeout(duration, my_async_mutex.lock()).await

[johannescpk]

That makes sense, thanks! I guess it should be easy enough to wrap that into a custom trait then 🤔

[hawkw]

Could be worth adding an example of this to the documentation, for future readers?

[johannescpk]

FWIW, here's a tiny example I've been experimenting with, not sure if/where something like that would fit into the docs

#[derive(Debug)]
pub struct TimedRwLock<T> {
    inner: tokio::sync::RwLock<T>,
    timeout: std::time::Duration,
}

impl<T> TimedRwLock<T> {
    pub fn new(value: T, timeout: std::time::Duration) -> Self {
        Self { inner: tokio::sync::RwLock::new(value), timeout }
    }

    pub async fn read(&self) -> eyre::Result<tokio::sync::RwLockReadGuard<'_, T>> {
        let read_guard = tokio::time::timeout(self.timeout, self.inner.read()).await?;

        Ok(read_guard)
    }

    pub async fn write(&self) -> eyre::Result<tokio::sync::RwLockWriteGuard<'_, T>> {
        let write_guard = tokio::time::timeout(self.timeout, self.inner.write()).await?;

        Ok(write_guard)
    }
}

impl<T> std::ops::Deref for TimedRwLock<T> {
    type Target = tokio::sync::RwLock<T>;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<T: Default> Default for TimedRwLock<T> {
    fn default() -> Self {
        Self::new(T::default(), std::time::Duration::from_secs(60))
    }
}

[Darksonn]

I think for the documentation, a note or short example would do.