fix atomic factory soak test (#419)

* volatile

* defer volatile

* detect evicted

* dict

* use dict

---------

Author: bitfaster

BitFaster.Caching.UnitTests/Atomic/AtomicFactorySoakTests.cs

@@ -1,5 +1,7 @@
-using System.Linq;
+using System.Collections.Concurrent;
+using System.Linq;
 using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
 using BitFaster.Caching.Lru;
 using FluentAssertions;
 using Xunit;
@@ -12,19 +14,20 @@ public class AtomicFactorySoakTests
         [Fact]
         public async Task WhenGetOrAddIsConcurrentValuesCreatedAtomically()
         {
-            var cache = new ConcurrentLruBuilder<int, int>().WithAtomicGetOrAdd().WithCapacity(1024).Build();
+            const int threads = 4;
+            const int items = 1024;
+            var dictionary = new ConcurrentDictionary<int, AtomicFactory<int, int>>(concurrencyLevel: threads, capacity: items);
+            var counters = new int[threads];
 
-            var counters = new int[4];
-
-            await Threaded.Run(4, (r) =>
+            await Threaded.Run(threads, (r) =>
             {
-                for (int i = 0; i < 1024; i++)
+                for (int i = 0; i < items; i++)
                 {
-                    cache.GetOrAdd(i, k => { counters[r]++; return k; });
+                    dictionary.GetOrAdd(i, k => { counters[r]++; return k; });
                 }
             });
 
-            counters.Sum(x => x).Should().Be(1024);
+            counters.Sum(x => x).Should().Be(items);
         }
     }
 }

BitFaster.Caching/Atomic/AtomicFactory.cs

@@ -74,7 +74,7 @@ public V GetValue<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgume
         /// <summary>
         /// Gets a value indicating whether the value has been initialized.
         /// </summary>
-        public bool IsValueCreated => initializer == null;
+        public bool IsValueCreated => Volatile.Read(ref initializer) == null;
 
         /// <summary>
         /// Gets the value if it has been initialized, else default.
@@ -94,12 +94,12 @@ public V ValueIfCreated
 
         private V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
         {
-            var init = initializer;
+            var init = Volatile.Read(ref initializer);
 
             if (init != null)
             {
                 value = init.CreateValue(key, valueFactory);
-                initializer = null;
+                Volatile.Write(ref initializer, null); // volatile write must occur after setting value
             }
 
             return value;
@@ -135,18 +135,12 @@ public override int GetHashCode()
 
         private class Initializer
         {
-            private readonly object syncLock = new();
             private bool isInitialized;
             private V value;
 
             public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
             {
-                if (Volatile.Read(ref isInitialized))
-                {
-                    return value;
-                }
-
-                lock (syncLock)
+                lock (this)
                 {
                     if (Volatile.Read(ref isInitialized))
                     {