Wait 10 or more seconds before flushing last accessed date changes to disk in the disk cache - this drastically reduces race conditions where a SetLastAccessTimeUtc call prevents a cached file from being read.

Author: lilith

src/Imazen.DiskCache/Cleanup/CleanupManager.cs

@@ -3,13 +3,43 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Imazen.Common.Extensibility.ClassicDiskCache;
 using Imazen.Common.Issues;
 using Microsoft.Extensions.Logging;
 
 namespace Imazen.DiskCache {
 
-   
+    internal static class TaskExtensions
+    {
+        // Allocate the async/await state machine only when needed for performance reason.
+        // More info about the state machine: https://blogs.msdn.microsoft.com/seteplia/2017/11/30/dissecting-the-async-methods-in-c/
+        static async Task ForgetAwaited(Task task)
+        {
+            try
+            {
+                // No need to resume on the original SynchronizationContext, so use ConfigureAwait(false)
+                await task.ConfigureAwait(false);
+            }
+            catch
+            {
+                // Nothing to do here
+            }
+        }
+        public static void Forget(this Task task)
+        {
+            // note: this code is inspired by a tweet from Ben Adams: https://twitter.com/ben_a_adams/status/1045060828700037125
+            // Only care about tasks that may fault (not completed) or are faulted,
+            // so fast-path for SuccessfullyCompleted and Canceled tasks.
+            if (!task.IsCompleted || task.IsFaulted)
+            {
+                // use "_" (Discard operation) to remove the warning IDE0058: Because this call is not awaited, execution of the current method continues before the call is completed
+                // https://docs.microsoft.com/en-us/dotnet/csharp/discards#a-standalone-discard
+                _ = ForgetAwaited(task);
+            }
+        }
+    }
+    
     internal class CleanupManager:IIssueProvider, IDisposable {
         private readonly ICleanableCache cache = null;
         private readonly CleanupStrategy cs = null;
@@ -81,10 +111,17 @@ public void CleanAll() {
         public void UsedFile(string relativePath, string physicalPath) {
             //Bump the date in memory
             cache.Index.bumpDateIfExists(relativePath);
-            //Make sure the 'flush' job for the file is in the queue somewhere, so the access date will get written to disk.
-            queue.QueueIfUnique(new CleanupWorkItem(CleanupWorkItem.Kind.FlushAccessedDate, relativePath, physicalPath));
-            //In case it's paused
-            worker.MayHaveWork();
+            
+            Task.Run(async () =>
+            {
+                // Wait 10 seconds to give the reader thread time to open the file first. 
+                await Task.Delay(10000);
+                //Make sure the 'flush' job for the file is in the queue somewhere, so the access date will get written to disk.
+                queue.QueueIfUnique(new CleanupWorkItem(CleanupWorkItem.Kind.FlushAccessedDate, relativePath,
+                    physicalPath));
+                //In case it's paused
+                worker.MayHaveWork();
+            }).Forget();
         }