soak test ScopedAtomicFactory (#427)

* soak

* simplify

* test dispose

* dispose

---------

Author: bitfaster

BitFaster.Caching.UnitTests/Atomic/ScopedAtomicFactorySoakTests.cs

@@ -0,0 +1,81 @@
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    [Collection("Soak")]
+    public class ScopedAtomicFactorySoakTests
+    {
+        [Fact]
+        public async Task WhenGetOrAddIsConcurrentValuesCreatedAtomically()
+        {
+            const int threads = 4;
+            const int items = 1024;
+            var dictionary = new ConcurrentDictionary<int, ScopedAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
+            var counters = new int[threads];
+
+            await Threaded.Run(threads, (r) =>
+            {
+                for (int i = 0; i < items; i++)
+                {
+                    while (true)
+                    {
+                        var scoped = dictionary.GetOrAdd(i, k => new ScopedAtomicFactory<int, Disposable>());
+                        if (scoped.TryCreateLifetime(i, k => { counters[r]++; return new Scoped<Disposable>(new Disposable(k)); }, out var lifetime))
+                        {
+                            using (lifetime)
+                            {
+                                lifetime.Value.IsDisposed.Should().BeFalse();
+                            }
+
+                            break;
+                        }
+                    }
+
+                }
+            });
+
+            counters.Sum(x => x).Should().Be(items);
+        }
+
+        [Fact]
+        public async Task WhenGetOrAddAndDisposeIsConcurrentValuesCreatedAtomically()
+        {
+            const int threads = 4;
+            const int items = 1024;
+            var dictionary = new ConcurrentDictionary<int, ScopedAtomicFactory<int, Disposable>>(concurrencyLevel: threads, capacity: items);
+            var counters = new int[threads];
+
+            await Threaded.Run(threads, (r) =>
+            {
+                for (int i = 0; i < items; i++)
+                {
+                    if (dictionary.TryRemove(i, out var d))
+                    {
+                        d.Dispose();
+                    }
+
+                    while (true)
+                    {
+                        var scoped = dictionary.GetOrAdd(i, k => new ScopedAtomicFactory<int, Disposable>());
+
+                        if (scoped.TryCreateLifetime(i, k => { counters[r]++; return new Scoped<Disposable>(new Disposable(k)); }, out var lifetime))
+                        {
+                            using (lifetime)
+                            {
+                                lifetime.Value.IsDisposed.Should().BeFalse();
+                            }
+
+                            break;
+                        }
+                    }
+
+                }
+            });
+        }
+    }
+}

BitFaster.Caching/Atomic/ScopedAtomicFactory.cs

@@ -136,7 +136,7 @@ private void InitializeScope<TFactory>(K key, TFactory valueFactory) where TFact
             if (init != null)
             {
                 scope = init.CreateScope(key, valueFactory);
-                initializer = null;
+                Volatile.Write(ref initializer, null); // volatile write must occur after setting value
             }
         }
 
@@ -164,11 +164,6 @@ private class Initializer
 
             public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
             {
-                if (Volatile.Read(ref isInitialized))
-                {
-                    return value;
-                }
-
                 lock (syncLock)
                 {
                     if (Volatile.Read(ref isInitialized))
@@ -185,12 +180,6 @@ public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFact
 
             public Scoped<V> TryCreateDisposedScope()
             {
-                // already exists, return it
-                if (Volatile.Read(ref isInitialized))
-                {
-                    return value;
-                }
-
                 lock (syncLock)
                 {
                     if (Volatile.Read(ref isInitialized))