diff --git a/BitFaster.Caching.Benchmarks/Lfu/CmSketchFlat.cs b/BitFaster.Caching.Benchmarks/Lfu/CmSketchFlat.cs
index b70ec3af..fee80984 100644
--- a/BitFaster.Caching.Benchmarks/Lfu/CmSketchFlat.cs
+++ b/BitFaster.Caching.Benchmarks/Lfu/CmSketchFlat.cs
@@ -199,7 +199,7 @@ private int IndexOf(int item, int i)
             return ((int)hash) & tableMask;
         }
 
-        private int Spread(int x)
+        private static int Spread(int x)
         {
             uint y = (uint)x;
             y = ((y >> 16) ^ y) * 0x45d9f3b;
diff --git a/BitFaster.Caching.Benchmarks/LockBench.cs b/BitFaster.Caching.Benchmarks/LockBench.cs
new file mode 100644
index 00000000..c8ef40a8
--- /dev/null
+++ b/BitFaster.Caching.Benchmarks/LockBench.cs
@@ -0,0 +1,60 @@
+using System.Threading;
+using Benchly;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace BitFaster.Caching.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net90)]
+    [MemoryDiagnoser(displayGenColumns: false)]
+    [HideColumns("Job", "Median", "RatioSD", "Alloc Ratio")]
+    [ColumnChart(Title = "Try enter ({JOB})")]
+    public class LockBench
+    {
+        private int _value;
+        private readonly object monitorLock = new object();
+#if NET9_0_OR_GREATER
+        private readonly Lock threadingLock = new Lock();
+#endif
+
+        [Benchmark(Baseline = true)]
+        public void UseMonitor()
+        {
+            bool lockTaken = false;
+            Monitor.TryEnter(monitorLock, ref lockTaken);
+
+            if (lockTaken)
+            {
+                try
+                {
+                    _value++;
+                }
+                finally
+                {
+                    if (lockTaken)
+                    {
+                        Monitor.Exit(monitorLock);
+                    }
+                }
+            }
+        }
+
+        [Benchmark()]
+        public void UseLock()
+        {
+#if NET9_0_OR_GREATER
+            if (threadingLock.TryEnter())
+            {
+                try
+                {
+                    _value++;
+                }
+                finally
+                {
+                    threadingLock.Exit();
+                }
+            }
+#endif
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Lru/TLruTickCount64PolicyTests .cs b/BitFaster.Caching.UnitTests/Lru/TLruTickCount64PolicyTests.cs
similarity index 100%
rename from BitFaster.Caching.UnitTests/Lru/TLruTickCount64PolicyTests .cs
rename to BitFaster.Caching.UnitTests/Lru/TLruTickCount64PolicyTests.cs
diff --git a/BitFaster.Caching/Atomic/AtomicEx.cs b/BitFaster.Caching/Atomic/AtomicEx.cs
index 0ead94be..1e600ab1 100644
--- a/BitFaster.Caching/Atomic/AtomicEx.cs
+++ b/BitFaster.Caching/Atomic/AtomicEx.cs
@@ -3,7 +3,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using System.Text;
 
 namespace BitFaster.Caching.Atomic
 {
@@ -21,6 +20,7 @@ internal static int EnumerateCount(IEnumerator enumerator)
 
         internal static ICollection<K> FilterKeys<K, V>(IEnumerable<KeyValuePair<K, V>> kvps, Func<V, bool> filter)
         {
+#pragma warning disable CA1851
             // Here we will double enumerate the kvps list. Alternative is to lazy init the size which will keep resizing
             // the List, and spam allocs if the list is long.
             List<K> keys = new List<K>(kvps.Count());
@@ -34,6 +34,7 @@ internal static ICollection<K> FilterKeys<K, V>(IEnumerable<KeyValuePair<K, V>>
             }
 
             return new ReadOnlyCollection<K>(keys);
+#pragma warning restore CA1851
         }
     }
 }
diff --git a/BitFaster.Caching/Lru/ConcurrentLru.cs b/BitFaster.Caching/Lru/ConcurrentLru.cs
index bd7192a6..36376a51 100644
--- a/BitFaster.Caching/Lru/ConcurrentLru.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLru.cs
@@ -40,13 +40,13 @@ internal static ICache<K, V> Create<K, V>(LruInfo<K> info)
             };
         }
 
-        private static ICache<K, V> CreateExpireAfterAccess<K, V, TP>(LruInfo<K> info) where K : notnull where TP : struct, ITelemetryPolicy<K, V>
+        private static ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, AfterAccessPolicy<K, V>, TP> CreateExpireAfterAccess<K, V, TP>(LruInfo<K> info) where K : notnull where TP : struct, ITelemetryPolicy<K, V>
         {
             return new ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, AfterAccessPolicy<K, V>, TP>(
                 info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessPolicy<K, V>(info.TimeToExpireAfterAccess!.Value), default);
         }
 
-        private static ICache<K, V> CreateExpireAfter<K, V, TP>(LruInfo<K> info, IExpiryCalculator<K, V> expiry) where K : notnull where TP : struct, ITelemetryPolicy<K, V>
+        private static ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, DiscretePolicy<K, V>, TP> CreateExpireAfter<K, V, TP>(LruInfo<K> info, IExpiryCalculator<K, V> expiry) where K : notnull where TP : struct, ITelemetryPolicy<K, V>
         {
             return new ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, DiscretePolicy<K, V>, TP>(
                 info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new DiscretePolicy<K, V>(expiry), default);