diff --git a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
index ff48ce40..eb1b9165 100644
--- a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
@@ -137,6 +137,7 @@ private async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFacto
 
         private class Initializer
         {
+            private readonly Lock locker = LockFactory.Create();
             private bool isInitialized;
             private Task<V>? valueTask;
 
@@ -178,7 +179,7 @@ private Task<V> DoubleCheck(Task<V> value)
                     return valueTask!;
                 }
 
-                lock (this)
+                lock (locker)
                 {
                     if (!isInitialized)
                     {
diff --git a/BitFaster.Caching/Atomic/AtomicFactory.cs b/BitFaster.Caching/Atomic/AtomicFactory.cs
index 8aaf8e3f..60876969 100644
--- a/BitFaster.Caching/Atomic/AtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactory.cs
@@ -159,13 +159,14 @@ public override int GetHashCode()
 #pragma warning disable CA2002 // Do not lock on objects with weak identity
         private class Initializer
         {
+            private readonly Lock locker = LockFactory.Create();
             private bool isInitialized;
             private V? value;
             private ExceptionDispatchInfo? exceptionDispatch;
 
             public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
             {
-                lock (this)
+                lock (locker)
                 {
                     if (isInitialized)
                     {
diff --git a/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
index 839b51a1..3a4acefc 100644
--- a/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
@@ -147,6 +147,7 @@ public void Dispose()
 
         private class Initializer
         {
+            private readonly Lock locker = LockFactory.Create();
             private bool isTaskInitialized;
             private bool isTaskCompleted;
             private bool isDisposeRequested;
@@ -197,7 +198,7 @@ private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)
                     return task!;
                 }
 
-                lock (this)
+                lock (locker)
                 {
                     if (!isTaskInitialized)
                     {
diff --git a/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
index 55661e99..e7686f35 100644
--- a/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
@@ -162,12 +162,13 @@ public void Dispose()
 #pragma warning disable CA2002 // Do not lock on objects with weak identity
         private class Initializer
         {
+            private readonly Lock locker = LockFactory.Create();
             private bool isInitialized;
             private Scoped<V>? value;
 
             public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
             {
-                lock (this)
+                lock (locker)
                 {
                     if (isInitialized)
                     {
@@ -183,7 +184,7 @@ public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFact
 
             public Scoped<V> TryCreateDisposedScope()
             {
-                lock (this)
+                lock (locker)
                 {
                     if (isInitialized)
                     {
diff --git a/BitFaster.Caching/BitFaster.Caching.csproj b/BitFaster.Caching/BitFaster.Caching.csproj
index c1304d11..83682ec3 100644
--- a/BitFaster.Caching/BitFaster.Caching.csproj
+++ b/BitFaster.Caching/BitFaster.Caching.csproj
@@ -54,7 +54,14 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
-  </ItemGroup>
+    <PackageReference Include="Backport.System.Threading.Lock" Version="3.1.4">
+       <PrivateAssets>all</PrivateAssets>
+       <IncludeAssets>analyzers</IncludeAssets>
+    </PackageReference>
+    <Using Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))" Alias="Lock" Include="System.Threading.Lock" />
+    <Using Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))" Alias="Lock" Include="Backport.System.Threading.Lock" />
+    <Using Alias="LockFactory" Include="Backport.System.Threading.LockFactory" />
+  </ItemGroup>    
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
      <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index b277c9ea..a7b07dd0 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -24,6 +24,7 @@ public sealed class ClassicLru<K, V> : ICacheExt<K, V>, IAsyncCacheExt<K, V>, IB
         private readonly int capacity;
         private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;
         private readonly LinkedList<LruItem> linkedList = new();
+        private readonly Lock locker = LockFactory.Create();
 
         private readonly CacheMetrics metrics = new();
         private readonly CachePolicy policy;
@@ -120,7 +121,7 @@ private bool TryAdd(K key, V value)
             {
                 LinkedListNode<LruItem>? first = null;
 
-                lock (this.linkedList)
+                lock (this.locker)
                 {
                     if (linkedList.Count >= capacity)
                     {
@@ -303,7 +304,7 @@ private void OnRemove(LinkedListNode<LruItem> node)
             // the List & Dictionary. Now thread A will try to move x to the end of the list.
             if (node.List != null)
             {
-                lock (this.linkedList)
+                lock (this.locker)
                 {
                     if (node.List != null)
                     {
@@ -350,7 +351,7 @@ public void AddOrUpdate(K key, V value)
             {
                 LinkedListNode<LruItem>? first = null;
 
-                lock (this.linkedList)
+                lock (this.locker)
                 {
                     if (linkedList.Count >= capacity)
                     {
@@ -410,7 +411,7 @@ public void Trim(int itemCount)
             {
                 LinkedListNode<LruItem>? first = null;
 
-                lock (this.linkedList)
+                lock (this.locker)
                 {
                     if (linkedList.Count > 0)
                     {
@@ -440,7 +441,7 @@ private void LockAndMoveToEnd(LinkedListNode<LruItem> node)
                 return;
             }
 
-            lock (this.linkedList)
+            lock (this.locker)
             {
                 if (node.List == null)
                 {