diff --git a/src/tools.rs b/src/tools.rs
index 5e0a6c01..5f3fb897 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -20,6 +20,7 @@ use std::collections::HashMap;
 
 use serde_json::Value;
 
+pub mod async_mutex;
 pub mod timer;
 pub mod wrapped_reader_stream;
 #[macro_use]
diff --git a/src/tools/async_mutex.rs b/src/tools/async_mutex.rs
new file mode 100644
index 00000000..12832146
--- /dev/null
+++ b/src/tools/async_mutex.rs
@@ -0,0 +1,40 @@
+use std::marker::PhantomData;
+
+use futures::Poll;
+use futures::future::Future;
+use tokio::sync::lock::Lock as TokioLock;
+pub use tokio::sync::lock::LockGuard as AsyncLockGuard;
+
+pub struct AsyncMutex<T>(TokioLock<T>);
+
+unsafe impl<T> Sync for AsyncMutex<T> {}
+
+impl<T> AsyncMutex<T> {
+    pub fn new(value: T) -> Self {
+        Self(TokioLock::new(value))
+    }
+
+    // <E> to allow any error type (we never error, so we have no error type of our own)
+    pub fn lock<E>(&self) -> LockFuture<T, E> {
+        LockFuture {
+            lock: self.0.clone(),
+            _error: PhantomData,
+        }
+    }
+}
+
+/// Represents a lock to be held in the future:
+pub struct LockFuture<T, E> {
+    lock: TokioLock<T>,
+    // We can't error and we don't want to enforce a specific error type either
+    _error: PhantomData<E>,
+}
+
+impl<T, E> Future for LockFuture<T, E> {
+    type Item = AsyncLockGuard<T>;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<AsyncLockGuard<T>, E> {
+        Ok(self.lock.poll_lock())
+    }
+}