Write lock only when applying changes on physical member (dispose, shutdown, =null ...)

=> so in normal run, only read locks are done => no slowdown out of connections problems because of read lock are reentrant

Author: jcaspes

src/StackExchange.Redis/PhysicalBridge.cs

@@ -205,7 +205,7 @@ public WriteResult TryWriteSync(Message message, bool isReplica)
             if (!IsConnected) return QueueOrFailMessage(message);
 
             WriteResult result = WriteResult.WriteFailure;
-            if (threadSafePhysicalConnectionAccessor.WorkOnPhysicalWithLock(physical =>
+            if (threadSafePhysicalConnectionAccessor.UsePhysicalWithLock(physical =>
             {
                 result = WriteMessageTakingWriteLockSync(physical, message);
                 LogNonPreferred(message.Flags, isReplica);
@@ -237,7 +237,7 @@ public ValueTask<WriteResult> TryWriteAsync(Message message, bool isReplica, boo
             }
 
             ValueTask<WriteResult> result = new ValueTask<WriteResult>(WriteResult.Success);
-            if (threadSafePhysicalConnectionAccessor.WorkOnPhysicalWithLock(physical =>
+            if (threadSafePhysicalConnectionAccessor.UsePhysicalWithLock(physical =>
             {
                 result = WriteMessageTakingWriteLockAsync(physical, message, bypassBacklog: bypassBacklog);
                 LogNonPreferred(message.Flags, isReplica);
@@ -414,7 +414,7 @@ internal void KeepAlive(bool forceRun = false)
             {
                 msg.SetInternalCall();
                 Multiplexer.Trace("Enqueue: " + msg);
-                threadSafePhysicalConnectionAccessor.WorkOnPhysicalWithLock(physical =>
+                threadSafePhysicalConnectionAccessor.UsePhysicalWithLock(physical =>
                 {
                     Multiplexer.OnInfoMessage($"heartbeat ({physical?.LastWriteSecondsAgo}s >= {ServerEndPoint.WriteEverySeconds}s, {physical?.GetSentAwaitingResponseCount()} waiting) '{msg.CommandAndKey}' on '{PhysicalName}' (v{features.Version})");
                     physical?.UpdateLastWriteTime(); // preemptively
@@ -747,7 +747,7 @@ internal bool TryEnqueue(List<Message> messages, bool isReplica)
                 return false;
             }
 
-            return threadSafePhysicalConnectionAccessor.WorkOnPhysicalWithLock(physical =>
+            return threadSafePhysicalConnectionAccessor.UsePhysicalWithLock(physical =>
             {
                 foreach (var message in messages)
                 {
@@ -1180,7 +1180,7 @@ private void ProcessBridgeBacklog()
                     try
                     {
                         _backlogStatus = BacklogStatus.WritingMessage;
-                        threadSafePhysicalConnectionAccessor.WorkOnPhysicalWithLock(physical =>
+                        threadSafePhysicalConnectionAccessor.UsePhysicalWithLock(physical =>
                         {
                             var result = WriteMessageInsideLock(physical, message);
                             if (result == WriteResult.Success)

src/StackExchange.Redis/ThreadSafePhysicalConnectionAccessor.cs

@@ -132,6 +132,24 @@ internal void Shutdown()
             }
         }
 
+        internal bool UsePhysicalWithLock(Action<PhysicalConnection> callBack)
+        {
+            try
+            {
+                rwLock.EnterReadLock();
+                if (physical != null)
+                {
+                    callBack(physical);
+                    return true;
+                }
+                return false;
+            }
+            finally
+            {
+                rwLock.ExitReadLock();
+            }
+        }
+
         internal bool WorkOnPhysicalWithLock(Action<PhysicalConnection> callBack)
         {
             try
@@ -154,25 +172,25 @@ internal void SimulateConnectionFailure(SimulatedFailureType failureType)
         {
             try
             {
-                rwLock.EnterWriteLock();
+                rwLock.EnterReadLock();
                 physical?.SimulateConnectionFailure(failureType);
             }
             finally
             {
-                rwLock.ExitWriteLock();
+                rwLock.ExitReadLock();
             }
         }
 
         internal void SetIdle()
         {
             try
             {
-                rwLock.EnterWriteLock();
+                rwLock.EnterReadLock();
                 physical?.SetIdle();
             }
             finally
             {
-                rwLock.ExitWriteLock();
+                rwLock.ExitReadLock();
             }
         }