diff --git a/Cargo.toml b/Cargo.toml
index d27857ca..db6d2e30 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,11 +21,15 @@ maintenance = { status = "experimental" }
 
 [features]
 sanitize = ['crossbeam-epoch/sanitize']
-std = ["crossbeam-epoch/std", "num_cpus"]
+std = ["crossbeam-epoch/std", "num_cpus", "parking_lot"]
 default = ["std"]
 
 [dependencies]
-parking_lot = "0.10"
+lock_api = "0.3.3"
+
+[dependencies.parking_lot]
+version = "0.10"
+optional = true
 
 [dependencies.num_cpus]
 version = "1.12.0"
diff --git a/src/iter/iter.rs b/src/iter/iter.rs
index 90364188..b83fba7f 100644
--- a/src/iter/iter.rs
+++ b/src/iter/iter.rs
@@ -6,12 +6,18 @@ use crossbeam_epoch::Guard;
 ///
 /// See [`HashMap::iter`](crate::HashMap::iter) for details.
 #[derive(Debug)]
-pub struct Iter<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Iter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
     pub(crate) guard: &'g Guard,
 }
 
-impl<'g, K, V> Iterator for Iter<'g, K, V> {
+impl<'g, K, V, L> Iterator for Iter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = (&'g K, &'g V);
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;
@@ -26,11 +32,17 @@ impl<'g, K, V> Iterator for Iter<'g, K, V> {
 ///
 /// See [`HashMap::keys`](crate::HashMap::keys) for details.
 #[derive(Debug)]
-pub struct Keys<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Keys<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
 }
 
-impl<'g, K, V> Iterator for Keys<'g, K, V> {
+impl<'g, K, V, L> Iterator for Keys<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = &'g K;
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;
@@ -42,12 +54,18 @@ impl<'g, K, V> Iterator for Keys<'g, K, V> {
 ///
 /// See [`HashMap::values`](crate::HashMap::values) for details.
 #[derive(Debug)]
-pub struct Values<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Values<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
     pub(crate) guard: &'g Guard,
 }
 
-impl<'g, K, V> Iterator for Values<'g, K, V> {
+impl<'g, K, V, L> Iterator for Values<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = &'g V;
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;
diff --git a/src/iter/traverser.rs b/src/iter/traverser.rs
index d309b746..43cddb6d 100644
--- a/src/iter/traverser.rs
+++ b/src/iter/traverser.rs
@@ -9,15 +9,18 @@ use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Guard, Shared};
 
 #[derive(Debug)]
-pub(crate) struct NodeIter<'g, K, V> {
+pub(crate) struct NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     /// Current table; update if resized
-    table: Option<&'g Table<K, V>>,
+    table: Option<&'g Table<K, V, L>>,
 
-    stack: Option<Box<TableStack<'g, K, V>>>,
-    spare: Option<Box<TableStack<'g, K, V>>>,
+    stack: Option<Box<TableStack<'g, K, V, L>>>,
+    spare: Option<Box<TableStack<'g, K, V, L>>>,
 
     /// The last bin entry iterated over
-    prev: Option<&'g Node<K, V>>,
+    prev: Option<&'g Node<K, V, L>>,
 
     /// Index of bin to use next
     index: usize,
@@ -34,8 +37,11 @@ pub(crate) struct NodeIter<'g, K, V> {
     guard: &'g Guard,
 }
 
-impl<'g, K, V> NodeIter<'g, K, V> {
-    pub(crate) fn new(table: Shared<'g, Table<K, V>>, guard: &'g Guard) -> Self {
+impl<'g, K, V, L> NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) fn new(table: Shared<'g, Table<K, V, L>>, guard: &'g Guard) -> Self {
         let (table, len) = if table.is_null() {
             (None, 0)
         } else {
@@ -58,7 +64,7 @@ impl<'g, K, V> NodeIter<'g, K, V> {
         }
     }
 
-    fn push_state(&mut self, t: &'g Table<K, V>, i: usize, n: usize) {
+    fn push_state(&mut self, t: &'g Table<K, V, L>, i: usize, n: usize) {
         let mut s = self.spare.take();
         if let Some(ref mut s) = s {
             self.spare = s.next.take();
@@ -114,8 +120,11 @@ impl<'g, K, V> NodeIter<'g, K, V> {
     }
 }
 
-impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
-    type Item = &'g Node<K, V>;
+impl<'g, K, V, L> Iterator for NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    type Item = &'g Node<K, V, L>;
     fn next(&mut self) -> Option<Self::Item> {
         let mut e = None;
         if let Some(prev) = self.prev {
@@ -182,11 +191,14 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
 }
 
 #[derive(Debug)]
-struct TableStack<'g, K, V> {
+struct TableStack<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     length: usize,
     index: usize,
-    table: &'g Table<K, V>,
-    next: Option<Box<TableStack<'g, K, V>>>,
+    table: &'g Table<K, V, L>,
+    next: Option<Box<TableStack<'g, K, V, L>>>,
 }
 
 #[cfg(test)]
@@ -194,7 +206,7 @@ mod tests {
     use super::*;
     use crate::raw::Table;
     use crossbeam_epoch::{self as epoch, Atomic, Owned};
-    use parking_lot::Mutex;
+    use lock_api::Mutex;
 
     #[test]
     fn iter_new() {
diff --git a/src/map.rs b/src/map.rs
index eec7ef4d..55ea8889 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -64,13 +64,19 @@ macro_rules! load_factor {
 /// See [`ahash`](https://github.com/tkaitchuck/ahash) for more information.
 ///
 /// See the [crate-level documentation](index.html) for details.
-pub struct HashMap<K, V, S = RandomState> {
+#[cfg(feature = "std")]
+pub struct HashMap<K, V, L = parking_lot::RawMutex, S = RandomState>
+where
+    L: lock_api::RawMutex,
+    S: BuildHasher,
+{
+    // NOTE: if you change any field here, you must _also_ change it in the copy below
     /// The array of bins. Lazily initialized upon first insertion.
     /// Size is always a power of two. Accessed directly by iterators.
-    table: Atomic<Table<K, V>>,
+    table: Atomic<Table<K, V, L>>,
 
     /// The next table to use; non-null only while resizing.
-    next_table: Atomic<Table<K, V>>,
+    next_table: Atomic<Table<K, V, L>>,
 
     /// The next table index (plus one) to split while resizing.
     transfer_index: AtomicIsize,
@@ -88,10 +94,36 @@ pub struct HashMap<K, V, S = RandomState> {
     build_hasher: S,
 }
 
-impl<K, V, S> Default for HashMap<K, V, S>
+/// A concurrent hash table.
+///
+/// Note that `ahash::RandomState`, the default value of `S`, is not
+/// cryptographically secure. Therefore it is strongly recommended that you do
+/// not use this hash for cryptographic purproses.
+/// See [`ahash`](https://github.com/tkaitchuck/ahash) for more information.
+///
+/// See the [crate-level documentation](index.html) for details.
+#[cfg(not(feature = "std"))]
+pub struct HashMap<K, V, L, S = RandomState>
+where
+    L: lock_api::RawMutex,
+    S: BuildHasher,
+{
+    // NOTE: this is, and must be, an exact copy of the `HashMap` definition above, with just the
+    // default type for `L` unset. This is because in no_std environments, there is no sensible
+    // default lock type for us to use.
+    table: Atomic<Table<K, V, L>>,
+    next_table: Atomic<Table<K, V, L>>,
+    transfer_index: AtomicIsize,
+    count: AtomicUsize,
+    size_ctl: AtomicIsize,
+    build_hasher: S,
+}
+
+impl<K, V, L, S> Default for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
+    L: lock_api::RawMutex,
     S: BuildHasher + Default,
 {
     fn default() -> Self {
@@ -99,10 +131,11 @@ where
     }
 }
 
-impl<K, V, S> HashMap<K, V, S>
+impl<K, V, L, S> HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
+    L: lock_api::RawMutex,
     S: BuildHasher + Default,
 {
     /// Creates a new, empty map with the default initial table size (16).
@@ -117,10 +150,11 @@ where
     }
 }
 
-impl<K, V, S> HashMap<K, V, S>
+impl<K, V, L, S> HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
+    L: lock_api::RawMutex,
     S: BuildHasher,
 {
     /// Creates an empty map which will use `hash_builder` to hash keys.
@@ -165,10 +199,11 @@ where
     }
 }
 
-impl<K, V, S> HashMap<K, V, S>
+impl<K, V, L, S> HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
+    L: lock_api::RawMutex,
     S: BuildHasher,
 {
     fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> u64 {
@@ -190,7 +225,7 @@ where
         self.get(key, &guard).is_some()
     }
 
-    fn get_node<'g, Q>(&'g self, key: &Q, guard: &'g Guard) -> Option<&'g Node<K, V>>
+    fn get_node<'g, Q>(&'g self, key: &Q, guard: &'g Guard) -> Option<&'g Node<K, V, L>>
     where
         K: Borrow<Q>,
         Q: ?Sized + Hash + Eq,
@@ -304,7 +339,7 @@ where
         unsafe { v.as_ref() }.map(|v| (&node.key, v))
     }
 
-    fn init_table<'g>(&'g self, guard: &'g Guard) -> Shared<'g, Table<K, V>> {
+    fn init_table<'g>(&'g self, guard: &'g Guard) -> Shared<'g, Table<K, V, L>> {
         loop {
             let table = self.table.load(Ordering::SeqCst, guard);
             // safety: we loaded the table while epoch was pinned. table won't be deallocated until
@@ -376,7 +411,7 @@ where
             value: Atomic::new(value),
             hash: h,
             next: Atomic::null(),
-            lock: parking_lot::Mutex::new(()),
+            lock: lock_api::Mutex::new(()),
         }));
 
         loop {
@@ -558,10 +593,10 @@ where
 
     fn help_transfer<'g>(
         &'g self,
-        table: Shared<'g, Table<K, V>>,
-        next_table: *const Table<K, V>,
+        table: Shared<'g, Table<K, V, L>>,
+        next_table: *const Table<K, V, L>,
         guard: &'g Guard,
-    ) -> Shared<'g, Table<K, V>> {
+    ) -> Shared<'g, Table<K, V, L>> {
         if table.is_null() || next_table.is_null() {
             return table;
         }
@@ -674,8 +709,8 @@ where
 
     fn transfer<'g>(
         &'g self,
-        table: Shared<'g, Table<K, V>>,
-        mut next_table: Shared<'g, Table<K, V>>,
+        table: Shared<'g, Table<K, V, L>>,
+        mut next_table: Shared<'g, Table<K, V, L>>,
         guard: &'g Guard,
     ) {
         // safety: table was read while `guard` was held. the code that drops table only drops it
@@ -911,7 +946,7 @@ where
                         *link = Owned::new(BinEntry::Node(Node {
                             hash: node.hash,
                             key: node.key.clone(),
-                            lock: parking_lot::Mutex::new(()),
+                            lock: lock_api::Mutex::new(()),
                             value: node.value.clone(),
                             next: Atomic::from(*link),
                         }))
@@ -1171,7 +1206,7 @@ where
 
                     // TODO: tree nodes
                     let mut e = bin;
-                    let mut pred: Shared<'_, BinEntry<K, V>> = Shared::null();
+                    let mut pred: Shared<'_, BinEntry<K, V, L>> = Shared::null();
                     loop {
                         // safety: either e is bin, in which case it is valid due to the above,
                         // or e was obtained from a next pointer. Any next pointer obtained from
@@ -1304,7 +1339,7 @@ where
     /// The iterator element type is `(&'g K, &'g V)`.
     ///
     /// To obtain a `Guard`, use [`epoch::pin`].
-    pub fn iter<'g>(&'g self, guard: &'g Guard) -> Iter<'g, K, V> {
+    pub fn iter<'g>(&'g self, guard: &'g Guard) -> Iter<'g, K, V, L> {
         let table = self.table.load(Ordering::SeqCst, guard);
         let node_iter = NodeIter::new(table, guard);
         Iter { node_iter, guard }
@@ -1314,7 +1349,7 @@ where
     /// The iterator element type is `&'g K`.
     ///
     /// To obtain a `Guard`, use [`epoch::pin`].
-    pub fn keys<'g>(&'g self, guard: &'g Guard) -> Keys<'g, K, V> {
+    pub fn keys<'g>(&'g self, guard: &'g Guard) -> Keys<'g, K, V, L> {
         let table = self.table.load(Ordering::SeqCst, guard);
         let node_iter = NodeIter::new(table, guard);
         Keys { node_iter }
@@ -1324,7 +1359,7 @@ where
     /// The iterator element type is `&'g V`.
     ///
     /// To obtain a `Guard`, use [`epoch::pin`].
-    pub fn values<'g>(&'g self, guard: &'g Guard) -> Values<'g, K, V> {
+    pub fn values<'g>(&'g self, guard: &'g Guard) -> Values<'g, K, V, L> {
         let table = self.table.load(Ordering::SeqCst, guard);
         let node_iter = NodeIter::new(table, guard);
         Values { node_iter, guard }
@@ -1359,11 +1394,12 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<K, V, S> PartialEq for HashMap<K, V, S>
+impl<K, V, L, S> PartialEq for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Eq + Hash,
     V: Sync + Send + PartialEq,
     S: BuildHasher,
+    L: lock_api::RawMutex,
 {
     fn eq(&self, other: &Self) -> bool {
         if self.len() != other.len() {
@@ -1377,20 +1413,22 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<K, V, S> Eq for HashMap<K, V, S>
+impl<K, V, L, S> Eq for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Eq + Hash,
     V: Sync + Send + Eq,
     S: BuildHasher,
+    L: lock_api::RawMutex,
 {
 }
 
 #[cfg(feature = "std")]
-impl<K, V, S> fmt::Debug for HashMap<K, V, S>
+impl<K, V, L, S> fmt::Debug for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Debug + Eq + Hash,
     V: Sync + Send + Debug,
     S: BuildHasher,
+    L: lock_api::RawMutex,
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let guard = epoch::pin();
@@ -1398,7 +1436,11 @@ where
     }
 }
 
-impl<K, V, S> Drop for HashMap<K, V, S> {
+impl<K, V, L, S> Drop for HashMap<K, V, L, S>
+where
+    L: lock_api::RawMutex,
+    S: BuildHasher,
+{
     fn drop(&mut self) {
         // safety: we have &mut self _and_ all references we have returned are bound to the
         // lifetime of their borrow of self, so there cannot be any outstanding references to
@@ -1423,11 +1465,12 @@ impl<K, V, S> Drop for HashMap<K, V, S> {
 }
 
 #[cfg(feature = "std")]
-impl<K, V, S> Extend<(K, V)> for &HashMap<K, V, S>
+impl<K, V, L, S> Extend<(K, V)> for &HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
     S: BuildHasher,
+    L: lock_api::RawMutex,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
@@ -1451,11 +1494,12 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<'a, K, V, S> Extend<(&'a K, &'a V)> for &HashMap<K, V, S>
+impl<'a, K, V, L, S> Extend<(&'a K, &'a V)> for &HashMap<K, V, L, S>
 where
     K: Sync + Send + Copy + Hash + Eq,
     V: Sync + Send + Copy,
     S: BuildHasher,
+    L: lock_api::RawMutex,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) {
@@ -1463,11 +1507,12 @@ where
     }
 }
 
-impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>
+impl<K, V, L, S> FromIterator<(K, V)> for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send,
     S: BuildHasher + Default,
+    L: lock_api::RawMutex,
 {
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         let mut iter = iter.into_iter();
@@ -1489,11 +1534,12 @@ where
     }
 }
 
-impl<'a, K, V, S> FromIterator<(&'a K, &'a V)> for HashMap<K, V, S>
+impl<'a, K, V, L, S> FromIterator<(&'a K, &'a V)> for HashMap<K, V, L, S>
 where
     K: Sync + Send + Copy + Hash + Eq,
     V: Sync + Send + Copy,
     S: BuildHasher + Default,
+    L: lock_api::RawMutex,
 {
     #[inline]
     fn from_iter<T: IntoIterator<Item = (&'a K, &'a V)>>(iter: T) -> Self {
@@ -1501,11 +1547,12 @@ where
     }
 }
 
-impl<'a, K, V, S> FromIterator<&'a (K, V)> for HashMap<K, V, S>
+impl<'a, K, V, L, S> FromIterator<&'a (K, V)> for HashMap<K, V, L, S>
 where
     K: Sync + Send + Copy + Hash + Eq,
     V: Sync + Send + Copy,
     S: BuildHasher + Default,
+    L: lock_api::RawMutex,
 {
     #[inline]
     fn from_iter<T: IntoIterator<Item = &'a (K, V)>>(iter: T) -> Self {
@@ -1514,13 +1561,14 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<K, V, S> Clone for HashMap<K, V, S>
+impl<K, V, L, S> Clone for HashMap<K, V, L, S>
 where
     K: Sync + Send + Clone + Hash + Eq,
     V: Sync + Send + Clone,
     S: BuildHasher + Clone,
+    L: lock_api::RawMutex,
 {
-    fn clone(&self) -> HashMap<K, V, S> {
+    fn clone(&self) -> HashMap<K, V, L, S> {
         let cloned_map = Self::with_capacity_and_hasher(self.build_hasher.clone(), self.len());
         {
             let guard = epoch::pin();
diff --git a/src/node.rs b/src/node.rs
index eef5bb62..84cacfdb 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -2,14 +2,17 @@ use crate::raw::Table;
 use core::borrow::Borrow;
 use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Atomic, Guard, Shared};
-use parking_lot::Mutex;
+use lock_api::Mutex;
 
 /// Entry in a bin.
 ///
 /// Will _generally_ be `Node`. Any entry that is not first in the bin, will be a `Node`.
 #[derive(Debug)]
-pub(crate) enum BinEntry<K, V> {
-    Node(Node<K, V>),
+pub(crate) enum BinEntry<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    Node(Node<K, V, L>),
     // safety: the pointer t to the next table inside Moved(t) is a valid pointer if the Moved(t)
     // entry was read after loading `map::HashMap.table` while the guard used to load that table is
     // still alive:
@@ -40,29 +43,36 @@ pub(crate) enum BinEntry<K, V> {
     //
     // Since finishing a resize is the only time a table is `defer_destroy`ed, the above covers
     // all cases.
-    Moved(*const Table<K, V>),
+    Moved(*const Table<K, V, L>),
 }
 
-unsafe impl<K, V> Send for BinEntry<K, V>
+unsafe impl<K, V, L> Send for BinEntry<K, V, L>
 where
     K: Send,
     V: Send,
-    Node<K, V>: Send,
-    Table<K, V>: Send,
+    L: Send,
+    Node<K, V, L>: Send,
+    Table<K, V, L>: Send,
+    L: lock_api::RawMutex,
 {
 }
 
-unsafe impl<K, V> Sync for BinEntry<K, V>
+unsafe impl<K, V, L> Sync for BinEntry<K, V, L>
 where
     K: Sync,
     V: Sync,
-    Node<K, V>: Sync,
-    Table<K, V>: Sync,
+    L: Sync,
+    Node<K, V, L>: Sync,
+    Table<K, V, L>: Sync,
+    L: lock_api::RawMutex,
 {
 }
 
-impl<K, V> BinEntry<K, V> {
-    pub(crate) fn as_node(&self) -> Option<&Node<K, V>> {
+impl<K, V, L> BinEntry<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) fn as_node(&self) -> Option<&Node<K, V, L>> {
         if let BinEntry::Node(ref n) = *self {
             Some(n)
         } else {
@@ -71,13 +81,16 @@ impl<K, V> BinEntry<K, V> {
     }
 }
 
-impl<K, V> BinEntry<K, V> {
+impl<K, V, L> BinEntry<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     pub(crate) fn find<'g, Q>(
         &'g self,
         hash: u64,
         key: &Q,
         guard: &'g Guard,
-    ) -> Shared<'g, BinEntry<K, V>>
+    ) -> Shared<'g, BinEntry<K, V, L>>
     where
         K: Borrow<Q>,
         Q: ?Sized + Eq,
@@ -139,10 +152,13 @@ impl<K, V> BinEntry<K, V> {
 
 /// Key-value entry.
 #[derive(Debug)]
-pub(crate) struct Node<K, V> {
+pub(crate) struct Node<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     pub(crate) hash: u64,
     pub(crate) key: K,
     pub(crate) value: Atomic<V>,
-    pub(crate) next: Atomic<BinEntry<K, V>>,
-    pub(crate) lock: Mutex<()>,
+    pub(crate) next: Atomic<BinEntry<K, V, L>>,
+    pub(crate) lock: Mutex<L, ()>,
 }
diff --git a/src/raw/mod.rs b/src/raw/mod.rs
index 99880c14..8e04df49 100644
--- a/src/raw/mod.rs
+++ b/src/raw/mod.rs
@@ -8,19 +8,28 @@ use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Atomic, Guard, Owned, Shared};
 
 #[derive(Debug)]
-pub(crate) struct Table<K, V> {
-    bins: Box<[Atomic<BinEntry<K, V>>]>,
+pub(crate) struct Table<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    bins: Box<[Atomic<BinEntry<K, V, L>>]>,
 }
 
-impl<K, V> From<Vec<Atomic<BinEntry<K, V>>>> for Table<K, V> {
-    fn from(bins: Vec<Atomic<BinEntry<K, V>>>) -> Self {
+impl<K, V, L> From<Vec<Atomic<BinEntry<K, V, L>>>> for Table<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    fn from(bins: Vec<Atomic<BinEntry<K, V, L>>>) -> Self {
         Self {
             bins: bins.into_boxed_slice(),
         }
     }
 }
 
-impl<K, V> Table<K, V> {
+impl<K, V, L> Table<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     pub(crate) fn new(bins: usize) -> Self {
         Self::from(vec![Atomic::null(); bins])
     }
@@ -81,7 +90,10 @@ impl<K, V> Table<K, V> {
     }
 }
 
-impl<K, V> Drop for Table<K, V> {
+impl<K, V, L> Drop for Table<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     fn drop(&mut self) {
         // we need to drop any forwarding nodes (since they are heap allocated).
 
@@ -106,7 +118,10 @@ impl<K, V> Drop for Table<K, V> {
     }
 }
 
-impl<K, V> Table<K, V> {
+impl<K, V, L> Table<K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     #[inline]
     pub(crate) fn bini(&self, hash: u64) -> usize {
         let mask = self.bins.len() as u64 - 1;
@@ -114,7 +129,7 @@ impl<K, V> Table<K, V> {
     }
 
     #[inline]
-    pub(crate) fn bin<'g>(&'g self, i: usize, guard: &'g Guard) -> Shared<'g, BinEntry<K, V>> {
+    pub(crate) fn bin<'g>(&'g self, i: usize, guard: &'g Guard) -> Shared<'g, BinEntry<K, V, L>> {
         self.bins[i].load(Ordering::Acquire, guard)
     }
 
@@ -123,18 +138,22 @@ impl<K, V> Table<K, V> {
     pub(crate) fn cas_bin<'g>(
         &'g self,
         i: usize,
-        current: Shared<'_, BinEntry<K, V>>,
-        new: Owned<BinEntry<K, V>>,
+        current: Shared<'_, BinEntry<K, V, L>>,
+        new: Owned<BinEntry<K, V, L>>,
         guard: &'g Guard,
     ) -> Result<
-        Shared<'g, BinEntry<K, V>>,
-        crossbeam_epoch::CompareAndSetError<'g, BinEntry<K, V>, Owned<BinEntry<K, V>>>,
+        Shared<'g, BinEntry<K, V, L>>,
+        crossbeam_epoch::CompareAndSetError<'g, BinEntry<K, V, L>, Owned<BinEntry<K, V, L>>>,
     > {
         self.bins[i].compare_and_set(current, new, Ordering::AcqRel, guard)
     }
 
     #[inline]
-    pub(crate) fn store_bin<P: crossbeam_epoch::Pointer<BinEntry<K, V>>>(&self, i: usize, new: P) {
+    pub(crate) fn store_bin<P: crossbeam_epoch::Pointer<BinEntry<K, V, L>>>(
+        &self,
+        i: usize,
+        new: P,
+    ) {
         self.bins[i].store(new, Ordering::Release)
     }
 }