Speed optimization for .NET 9.0+ through System.Threading.Lock

MarkCiliaVincenti · MarkCiliaVincenti · commit 43ed3ba0c88e · 2025-06-28T16:00:30.000+02:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netcoreapp3.1;net6.0</TargetFrameworks>
-    <LangVersion>11.0</LangVersion>
+    <TargetFrameworks>netstandard2.0;netcoreapp3.1;net6.0;net9.0</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
     <Authors>Alex Peck</Authors>
     <Company />
     <Product>BitFaster.Caching</Product>
@@ -54,7 +54,11 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
-  </ItemGroup>
+    <PackageReference Include="Backport.System.Threading.Lock" Version="3.1.4" />  
+    <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
@@ -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)
                 {

Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,7 @@ private async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFacto`
`137`	`137`
`138`	`138`	`private class Initializer`
`139`	`139`	`{`
	`140`	`+ private readonly Lock locker = LockFactory.Create();`
`140`	`141`	`private bool isInitialized;`
`141`	`142`	`private Task<V>? valueTask;`
`142`	`143`
`@@ -178,7 +179,7 @@ private Task<V> DoubleCheck(Task<V> value)`
`178`	`179`	`return valueTask!;`
`179`	`180`	`}`
`180`	`181`
`181`		`- lock (this)`
	`182`	`+ lock (locker)`
`182`	`183`	`{`
`183`	`184`	`if (!isInitialized)`
`184`	`185`	`{`
Original file line number	Diff line number	Diff line change
`@@ -159,13 +159,14 @@ public override int GetHashCode()`
`159`	`159`	`#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`160`	`160`	`private class Initializer`
`161`	`161`	`{`
	`162`	`+ private readonly Lock locker = LockFactory.Create();`
`162`	`163`	`private bool isInitialized;`
`163`	`164`	`private V? value;`
`164`	`165`	`private ExceptionDispatchInfo? exceptionDispatch;`
`165`	`166`
`166`	`167`	`public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>`
`167`	`168`	`{`
`168`		`- lock (this)`
	`169`	`+ lock (locker)`
`169`	`170`	`{`
`170`	`171`	`if (isInitialized)`
`171`	`172`	`{`
Original file line number	Diff line number	Diff line change
`@@ -147,6 +147,7 @@ public void Dispose()`
`147`	`147`
`148`	`148`	`private class Initializer`
`149`	`149`	`{`
	`150`	`+ private readonly Lock locker = LockFactory.Create();`
`150`	`151`	`private bool isTaskInitialized;`
`151`	`152`	`private bool isTaskCompleted;`
`152`	`153`	`private bool isDisposeRequested;`
`@@ -197,7 +198,7 @@ private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)`
`197`	`198`	`return task!;`
`198`	`199`	`}`
`199`	`200`
`200`		`- lock (this)`
	`201`	`+ lock (locker)`
`201`	`202`	`{`
`202`	`203`	`if (!isTaskInitialized)`
`203`	`204`	`{`
Original file line number	Diff line number	Diff line change
`@@ -162,12 +162,13 @@ public void Dispose()`
`162`	`162`	`#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`163`	`163`	`private class Initializer`
`164`	`164`	`{`
	`165`	`+ private readonly Lock locker = LockFactory.Create();`
`165`	`166`	`private bool isInitialized;`
`166`	`167`	`private Scoped<V>? value;`
`167`	`168`
`168`	`169`	`public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>`
`169`	`170`	`{`
`170`		`- lock (this)`
	`171`	`+ lock (locker)`
`171`	`172`	`{`
`172`	`173`	`if (isInitialized)`
`173`	`174`	`{`
`@@ -183,7 +184,7 @@ public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFact`
`183`	`184`
`184`	`185`	`public Scoped<V> TryCreateDisposedScope()`
`185`	`186`	`{`
`186`		`- lock (this)`
	`187`	`+ lock (locker)`
`187`	`188`	`{`
`188`	`189`	`if (isInitialized)`
`189`	`190`	`{`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ public sealed class ClassicLru<K, V> : ICacheExt<K, V>, IAsyncCacheExt<K, V>, IB`
`24`	`24`	`private readonly int capacity;`
`25`	`25`	`private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;`
`26`	`26`	`private readonly LinkedList<LruItem> linkedList = new();`
	`27`	`+ private readonly Lock locker = LockFactory.Create();`
`27`	`28`
`28`	`29`	`private readonly CacheMetrics metrics = new();`
`29`	`30`	`private readonly CachePolicy policy;`
`@@ -120,7 +121,7 @@ private bool TryAdd(K key, V value)`
`120`	`121`	`{`
`121`	`122`	`LinkedListNode<LruItem>? first = null;`
`122`	`123`
`123`		`- lock (this.linkedList)`
	`124`	`+ lock (this.locker)`
`124`	`125`	`{`
`125`	`126`	`if (linkedList.Count >= capacity)`
`126`	`127`	`{`
`@@ -303,7 +304,7 @@ private void OnRemove(LinkedListNode<LruItem> node)`
`303`	`304`	`// the List & Dictionary. Now thread A will try to move x to the end of the list.`
`304`	`305`	`if (node.List != null)`
`305`	`306`	`{`
`306`		`- lock (this.linkedList)`
	`307`	`+ lock (this.locker)`
`307`	`308`	`{`
`308`	`309`	`if (node.List != null)`
`309`	`310`	`{`
`@@ -350,7 +351,7 @@ public void AddOrUpdate(K key, V value)`
`350`	`351`	`{`
`351`	`352`	`LinkedListNode<LruItem>? first = null;`
`352`	`353`
`353`		`- lock (this.linkedList)`
	`354`	`+ lock (this.locker)`
`354`	`355`	`{`
`355`	`356`	`if (linkedList.Count >= capacity)`
`356`	`357`	`{`
`@@ -410,7 +411,7 @@ public void Trim(int itemCount)`
`410`	`411`	`{`
`411`	`412`	`LinkedListNode<LruItem>? first = null;`
`412`	`413`
`413`		`- lock (this.linkedList)`
	`414`	`+ lock (this.locker)`
`414`	`415`	`{`
`415`	`416`	`if (linkedList.Count > 0)`
`416`	`417`	`{`
`@@ -440,7 +441,7 @@ private void LockAndMoveToEnd(LinkedListNode<LruItem> node)`
`440`	`441`	`return;`
`441`	`442`	`}`
`442`	`443`
`443`		`- lock (this.linkedList)`
	`444`	`+ lock (this.locker)`
`444`	`445`	`{`
`445`	`446`	`if (node.List == null)`
`446`	`447`	`{`