Avoid unnecessary locking in SoftLimitMRUCache

bahusoid · bahusoid · commit 7096c7fa123d · 2019-09-23T11:29:11.000+03:00
diff --git a/src/NHibernate/Util/SimpleMRUCache.cs b/src/NHibernate/Util/SimpleMRUCache.cs
@@ -1,7 +1,5 @@
 using System;
-using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
-using System.Threading;
 
 namespace NHibernate.Util
 {
@@ -19,7 +17,7 @@ public class SimpleMRUCache : IDeserializationCallback
 	{
 		private const int DefaultStrongRefCount = 128;
 
-		private object _syncRoot;
+		private readonly object _syncRoot = new object();
 
 		private readonly int strongReferenceCount;
 
@@ -35,17 +33,6 @@ public SimpleMRUCache(int strongReferenceCount)
 			cache = new LRUMap(strongReferenceCount);
 		}
 
-		private object SyncRoot
-		{
-			get
-			{
-				if (_syncRoot == null)
-					Interlocked.CompareExchange(ref _syncRoot, new object(), null);
-
-				return _syncRoot;
-			}
-		}
-
 		#region IDeserializationCallback Members
 
 		void IDeserializationCallback.OnDeserialization(object sender)
@@ -57,41 +44,37 @@ void IDeserializationCallback.OnDeserialization(object sender)
 
 		public object this[object key]
 		{
-			[MethodImpl(MethodImplOptions.Synchronized)]
 			get
 			{
-				lock (SyncRoot)
+				lock (_syncRoot)
 				{
 					return cache[key];
 				}
 			}
 		}
 
-		[MethodImpl(MethodImplOptions.Synchronized)]
 		public void Put(object key, object value)
 		{
-			lock (SyncRoot)
+			lock (_syncRoot)
 			{
 				cache.Add(key, value);
 			}
 		}
 
 		public int Count
 		{
-			[MethodImpl(MethodImplOptions.Synchronized)]
 			get
 			{
-				lock (SyncRoot)
+				lock (_syncRoot)
 				{
 					return cache.Count;
 				}
 			}
 		}
 
-		[MethodImpl(MethodImplOptions.Synchronized)]
 		public void Clear()
 		{
-			lock (SyncRoot)
+			lock (_syncRoot)
 			{
 				cache.Clear();
 			}
diff --git a/src/NHibernate/Util/SoftLimitMRUCache.cs b/src/NHibernate/Util/SoftLimitMRUCache.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections;
-using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
-using System.Threading;
 
 namespace NHibernate.Util
 {
@@ -25,7 +23,7 @@ namespace NHibernate.Util
 	public class SoftLimitMRUCache : IDeserializationCallback
 	{
 		private const int DefaultStrongRefCount = 128;
-		private object _syncRoot;
+		private readonly object _syncRoot = new object();
 
 		private readonly int strongReferenceCount;
 
@@ -50,17 +48,6 @@ public SoftLimitMRUCache(int strongReferenceCount)
 		public SoftLimitMRUCache()
 			: this(DefaultStrongRefCount) {}
 
-		private object SyncRoot
-		{
-			get
-			{
-				if (_syncRoot == null)
-					Interlocked.CompareExchange(ref _syncRoot, new object(), null);
-
-				return _syncRoot;
-			}
-		}
-
 		#region IDeserializationCallback Members
 
 		void IDeserializationCallback.OnDeserialization(object sender)
@@ -72,10 +59,9 @@ void IDeserializationCallback.OnDeserialization(object sender)
 
 		public object this[object key]
 		{
-			[MethodImpl(MethodImplOptions.Synchronized)]
 			get
 			{
-				lock (SyncRoot)
+				lock (_syncRoot)
 				{
 					object result = softReferenceCache[key];
 					if (result != null)
@@ -87,10 +73,9 @@ public object this[object key]
 			}
 		}
 
-		[MethodImpl(MethodImplOptions.Synchronized)]
 		public void Put(object key, object value)
 		{
-			lock (SyncRoot)
+			lock (_syncRoot)
 			{
 				softReferenceCache[key] = value;
 				strongReferenceCache[key] = value;
@@ -99,10 +84,9 @@ public void Put(object key, object value)
 
 		public int Count
 		{
-			[MethodImpl(MethodImplOptions.Synchronized)]
 			get
 			{
-				lock (SyncRoot)
+				lock (_syncRoot)
 				{
 					return strongReferenceCache.Count;
 				}
@@ -111,20 +95,18 @@ public int Count
 
 		public int SoftCount
 		{
-			[MethodImpl(MethodImplOptions.Synchronized)]
 			get
 			{
-				lock (SyncRoot)
+				lock (_syncRoot)
 				{
 					return softReferenceCache.Count;
 				}
 			}
 		}
 
-		[MethodImpl(MethodImplOptions.Synchronized)]
 		public void Clear()
 		{
-			lock (SyncRoot)
+			lock (_syncRoot)
 			{
 				strongReferenceCache.Clear();
 				softReferenceCache.Clear();

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,5 @@`
`1`	`1`	`using System;`
`2`		`-using System.Runtime.CompilerServices;`
`3`	`2`	`using System.Runtime.Serialization;`
`4`		`-using System.Threading;`
`5`	`3`
`6`	`4`	`namespace NHibernate.Util`
`7`	`5`	`{`
`@@ -19,7 +17,7 @@ public class SimpleMRUCache : IDeserializationCallback`
`19`	`17`	`{`
`20`	`18`	`private const int DefaultStrongRefCount = 128;`
`21`	`19`
`22`		`- private object _syncRoot;`
	`20`	`+ private readonly object _syncRoot = new object();`
`23`	`21`
`24`	`22`	`private readonly int strongReferenceCount;`
`25`	`23`
`@@ -35,17 +33,6 @@ public SimpleMRUCache(int strongReferenceCount)`
`35`	`33`	`cache = new LRUMap(strongReferenceCount);`
`36`	`34`	`}`
`37`	`35`
`38`		`- private object SyncRoot`
`39`		`- {`
`40`		`- get`
`41`		`- {`
`42`		`- if (_syncRoot == null)`
`43`		`- Interlocked.CompareExchange(ref _syncRoot, new object(), null);`
`44`		`-`
`45`		`- return _syncRoot;`
`46`		`- }`
`47`		`- }`
`48`		`-`
`49`	`36`	`#region IDeserializationCallback Members`
`50`	`37`
`51`	`38`	`void IDeserializationCallback.OnDeserialization(object sender)`
`@@ -57,41 +44,37 @@ void IDeserializationCallback.OnDeserialization(object sender)`
`57`	`44`
`58`	`45`	`public object this[object key]`
`59`	`46`	`{`
`60`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`61`	`47`	`get`
`62`	`48`	`{`
`63`		`- lock (SyncRoot)`
	`49`	`+ lock (_syncRoot)`
`64`	`50`	`{`
`65`	`51`	`return cache[key];`
`66`	`52`	`}`
`67`	`53`	`}`
`68`	`54`	`}`
`69`	`55`
`70`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`71`	`56`	`public void Put(object key, object value)`
`72`	`57`	`{`
`73`		`- lock (SyncRoot)`
	`58`	`+ lock (_syncRoot)`
`74`	`59`	`{`
`75`	`60`	`cache.Add(key, value);`
`76`	`61`	`}`
`77`	`62`	`}`
`78`	`63`
`79`	`64`	`public int Count`
`80`	`65`	`{`
`81`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`82`	`66`	`get`
`83`	`67`	`{`
`84`		`- lock (SyncRoot)`
	`68`	`+ lock (_syncRoot)`
`85`	`69`	`{`
`86`	`70`	`return cache.Count;`
`87`	`71`	`}`
`88`	`72`	`}`
`89`	`73`	`}`
`90`	`74`
`91`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`92`	`75`	`public void Clear()`
`93`	`76`	`{`
`94`		`- lock (SyncRoot)`
	`77`	`+ lock (_syncRoot)`
`95`	`78`	`{`
`96`	`79`	`cache.Clear();`
`97`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections;`
`3`		`-using System.Runtime.CompilerServices;`
`4`	`3`	`using System.Runtime.Serialization;`
`5`		`-using System.Threading;`
`6`	`4`
`7`	`5`	`namespace NHibernate.Util`
`8`	`6`	`{`
`@@ -25,7 +23,7 @@ namespace NHibernate.Util`
`25`	`23`	`public class SoftLimitMRUCache : IDeserializationCallback`
`26`	`24`	`{`
`27`	`25`	`private const int DefaultStrongRefCount = 128;`
`28`		`- private object _syncRoot;`
	`26`	`+ private readonly object _syncRoot = new object();`
`29`	`27`
`30`	`28`	`private readonly int strongReferenceCount;`
`31`	`29`
`@@ -50,17 +48,6 @@ public SoftLimitMRUCache(int strongReferenceCount)`
`50`	`48`	`public SoftLimitMRUCache()`
`51`	`49`	`: this(DefaultStrongRefCount) {}`
`52`	`50`
`53`		`- private object SyncRoot`
`54`		`- {`
`55`		`- get`
`56`		`- {`
`57`		`- if (_syncRoot == null)`
`58`		`- Interlocked.CompareExchange(ref _syncRoot, new object(), null);`
`59`		`-`
`60`		`- return _syncRoot;`
`61`		`- }`
`62`		`- }`
`63`		`-`
`64`	`51`	`#region IDeserializationCallback Members`
`65`	`52`
`66`	`53`	`void IDeserializationCallback.OnDeserialization(object sender)`
`@@ -72,10 +59,9 @@ void IDeserializationCallback.OnDeserialization(object sender)`
`72`	`59`
`73`	`60`	`public object this[object key]`
`74`	`61`	`{`
`75`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`76`	`62`	`get`
`77`	`63`	`{`
`78`		`- lock (SyncRoot)`
	`64`	`+ lock (_syncRoot)`
`79`	`65`	`{`
`80`	`66`	`object result = softReferenceCache[key];`
`81`	`67`	`if (result != null)`
`@@ -87,10 +73,9 @@ public object this[object key]`
`87`	`73`	`}`
`88`	`74`	`}`
`89`	`75`
`90`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`91`	`76`	`public void Put(object key, object value)`
`92`	`77`	`{`
`93`		`- lock (SyncRoot)`
	`78`	`+ lock (_syncRoot)`
`94`	`79`	`{`
`95`	`80`	`softReferenceCache[key] = value;`
`96`	`81`	`strongReferenceCache[key] = value;`
`@@ -99,10 +84,9 @@ public void Put(object key, object value)`
`99`	`84`
`100`	`85`	`public int Count`
`101`	`86`	`{`
`102`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`103`	`87`	`get`
`104`	`88`	`{`
`105`		`- lock (SyncRoot)`
	`89`	`+ lock (_syncRoot)`
`106`	`90`	`{`
`107`	`91`	`return strongReferenceCache.Count;`
`108`	`92`	`}`
`@@ -111,20 +95,18 @@ public int Count`
`111`	`95`
`112`	`96`	`public int SoftCount`
`113`	`97`	`{`
`114`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`115`	`98`	`get`
`116`	`99`	`{`
`117`		`- lock (SyncRoot)`
	`100`	`+ lock (_syncRoot)`
`118`	`101`	`{`
`119`	`102`	`return softReferenceCache.Count;`
`120`	`103`	`}`
`121`	`104`	`}`
`122`	`105`	`}`
`123`	`106`
`124`		`- [MethodImpl(MethodImplOptions.Synchronized)]`
`125`	`107`	`public void Clear()`
`126`	`108`	`{`
`127`		`- lock (SyncRoot)`
	`109`	`+ lock (_syncRoot)`
`128`	`110`	`{`
`129`	`111`	`strongReferenceCache.Clear();`
`130`	`112`	`softReferenceCache.Clear();`