improve log

Author: arenchen

.github/workflows/deploy-nuget.yml

@@ -33,16 +33,16 @@ jobs:
           if [ ! -z "$PROJECT_PATH" ]; then
             APP=`basename "${PROJECT_PATH}" .csproj`
           fi
-          
+
           CHANGE_FILES=`git diff --no-commit-id --name-only HEAD^`
 
           CHANGED=`echo "$CHANGE_FILES" | grep -Em 1 '.cs|.proto' || true`
           if [ -z "$CHANGED" ] && [ "${{ inputs.force }}" != true ]; then
             echo "No changes detected"
-          
+
             APP=""
           fi
-          
+
           echo "app=${APP}" >> $GITHUB_OUTPUT
   Build:
     needs: Detect
@@ -62,5 +62,5 @@ jobs:
         name: Push Package
         with:
           artifact: ${{ needs.Build.outputs.artifact }}
-          nuget-api-url: ${{ secrets.NUGET_API_URL }}
+          nuget-api-url: ${{ vars.NUGET_API_URL }}
           nuget-api-key: ${{ secrets.NUGET_API_KEY }}

KeyCountLocker.cs

@@ -1,20 +1,26 @@
 using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
 
 namespace Netcorext.Extensions.Threading;
 
-public class KeyCountLocker
+public class KeyCountLocker : KeyLocker
 {
     private readonly long _minimum;
     private readonly long? _maximum;
     private static readonly ConcurrentDictionary<string, KeyLockerState<long>> CountLockers = new();
-    private static readonly KeyLocker Locker = new();
 
     public KeyCountLocker(long minimum = 1, long? maximum = null)
     {
         _minimum = minimum;
         _maximum = maximum;
     }
 
+    public KeyCountLocker(long minimum = 1, long? maximum = null, long deadLockTimes = DEFAULT_DEAD_LOCK_TIMES, ILogger? logger = null) : base(deadLockTimes, logger)
+    {
+        _minimum = minimum;
+        _maximum = maximum;
+    }
+
     public async Task<bool> IncrementAsync(string key, CancellationToken cancellationToken = default)
     {
         var newLocker = new KeyLockerState<long>
@@ -23,33 +29,33 @@ public async Task<bool> IncrementAsync(string key, CancellationToken cancellatio
                         };
         try
         {
-            await Locker.WaitAsync(key, cancellationToken);
+            await WaitAsync(key, cancellationToken);
 
             if (!CountLockers.TryGetValue(key, out var oldLocker))
                 return CountLockers.TryAdd(key, newLocker);
 
             if (oldLocker.State + 1 > _maximum)
                 return false;
-            
+
             newLocker.State = oldLocker.State + 1;
-            
+
             return CountLockers.TryUpdate(key, newLocker, oldLocker);
         }
         finally
         {
-            Locker.Release(key);
+            Release(key);
         }
     }
 
     public async Task<bool> DecrementAsync(string key, CancellationToken cancellationToken = default)
     {
         try
         {
-            await Locker.WaitAsync(key, cancellationToken);
+            await WaitAsync(key, cancellationToken);
 
             if (!CountLockers.TryGetValue(key, out var oldLocker))
                 return true;
-            
+
             var newLocker = new KeyLockerState<long>
                             {
                                 State = oldLocker.State - 1
@@ -62,7 +68,7 @@ public async Task<bool> DecrementAsync(string key, CancellationToken cancellatio
         }
         finally
         {
-            Locker.Release(key);
+            Release(key);
         }
     }
 
@@ -73,4 +79,4 @@ public Task<long> GetAsync(string key, CancellationToken cancellationToken = def
 
         return Task.FromResult(locker.State);
     }
-}
+}

KeyLocker.cs

@@ -1,11 +1,26 @@
 using System.Collections.Concurrent;
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
 
 namespace Netcorext.Extensions.Threading;
 
 public class KeyLocker
 {
+    public const long DEFAULT_DEAD_LOCK_TIMES = 100;
+
+    private readonly long _deadLockTimes = DEFAULT_DEAD_LOCK_TIMES;
+    private readonly ILogger? _logger;
     private static readonly ConcurrentDictionary<string, KeyLockerState<bool>> Lockers = new();
 
+    public KeyLocker()
+    { }
+
+    public KeyLocker(long deadLockTimes = DEFAULT_DEAD_LOCK_TIMES, ILogger? logger = null)
+    {
+        _deadLockTimes = deadLockTimes;
+        _logger = logger;
+    }
+
     public async Task WaitAsync(string key, CancellationToken cancellationToken = default)
     {
         await WaitAsync(key, null, false, cancellationToken);
@@ -18,6 +33,10 @@ public async Task WaitAsync(string key, TimeSpan? timeout = null, CancellationTo
 
     public async Task WaitAsync(string key, TimeSpan? timeout = null, bool releaseAll = false, CancellationToken cancellationToken = default)
     {
+        var stopwatch = new Stopwatch();
+
+        stopwatch.Start();
+
         while (!Lockers.TryAdd(key, new KeyLockerState<bool>
                                     {
                                         State = true,
@@ -36,8 +55,13 @@ public async Task WaitAsync(string key, TimeSpan? timeout = null, bool releaseAl
                 }
             }
 
+            if (_logger != null && stopwatch.ElapsedMilliseconds >= _deadLockTimes && stopwatch.ElapsedMilliseconds % _deadLockTimes == 0)
+                _logger.LogWarning("'{Key}' locked for too long, elapsed: {StopwatchElapsed}", key, stopwatch.Elapsed);
+
             await Task.Delay(1, cancellationToken);
         }
+
+        stopwatch.Stop();
     }
 
     public bool Release(string key)
@@ -65,7 +89,7 @@ public void Prune(params string[] keys)
         foreach (var key in keysToRemove)
         {
             if (Lockers.TryGetValue(key, out var locker) && locker.IsExpired)
-                Lockers.TryRemove(key, out _);    
+                Lockers.TryRemove(key, out _);
         }
     }
-}
+}

KeyLockerState.cs

@@ -5,4 +5,4 @@ public class KeyLockerState<T>
     public T? State { get; set; }
     public DateTimeOffset? Expires { get; set; }
     public bool IsExpired => Expires.HasValue && Expires.Value < DateTimeOffset.UtcNow;
-}
+}

Netcorext.Extensions.Threading.Locker.csproj

@@ -5,7 +5,7 @@
     <LangVersion>latest</LangVersion>
     <VersionMajor>1</VersionMajor>
     <VersionMinor>0</VersionMinor>
-    <VersionPatch>0</VersionPatch>
+    <VersionPatch>1</VersionPatch>
     <VersionPrefix>$(VersionMajor).$(VersionMinor).$(VersionPatch)</VersionPrefix>
     <VersionSuffix>$(VersionSuffix)</VersionSuffix>
     <FileVersion>$(VersionMajor).$([System.DateTime]::UtcNow.ToString(yy)).$([System.DateTime]::UtcNow.ToString(MMdd)).$([System.DateTime]::UtcNow.ToString(HHmm))</FileVersion>
@@ -22,11 +22,15 @@
     <Description>Threading Extensions for .NET Core</Description>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.*"  />
+  </ItemGroup>
+
   <Target Name="IncludeProjectReferences" DependsOnTargets="ResolveReferences">
     <ItemGroup>
       <IncludeBuildOutput />
       <BuildOutputInPackage Include="@(ReferenceCopyLocalPaths-&gt;WithMetadataValue('ReferenceSourceTarget', 'ProjectReference'))" />
     </ItemGroup>
   </Target>
 
-</Project>
+</Project>