Merge pull request #1 from mrdav30/develop

 Improved overall stability and predictability in multi-threaded environments.

Author: mrdav30

src/SwiftCollections/Pool/DefaultImplementations/SwiftArrayPool.cs

@@ -27,7 +27,7 @@ namespace SwiftCollections.Pool
         /// <summary>
         /// Tracks whether the pool has been disposed.
         /// </summary>
-        private bool _disposed;
+        private volatile bool _disposed;
 
         #endregion
 
@@ -165,10 +165,15 @@ public void Dispose()
 
         private void OnDispose()
         {
-            if (_disposed) return;
+            if (_disposed) 
+                return;
 
-            Clear();
             _disposed = true;
+
+            foreach (var pool in _sizePools.Values)
+                pool.Dispose();
+
+            _sizePools.Clear();
         }
 
         ~SwiftArrayPool() => OnDispose();  // Called by GC if Dispose() wasn't called explicitly.

src/SwiftCollections/Pool/SwiftObjectPool.cs

@@ -13,13 +13,15 @@ public sealed class SwiftObjectPool<T> : IDisposable, ISwiftObjectPool<T> where
     {
         #region Fields
 
-        private readonly ConcurrentBag<T> _pool;
+        private readonly ConcurrentStack<T> _pool;
         private readonly Func<T> _createFunc;
         private readonly Action<T> _actionOnGet;
         private readonly Action<T> _actionOnRelease;
         private readonly Action<T> _actionOnDestroy;
         private readonly int _maxSize;
 
+        private volatile bool _disposed;
+
         #endregion
 
         #region Constructor
@@ -44,7 +46,7 @@ public SwiftObjectPool(
             if (createFunc == null) ThrowHelper.ThrowArgumentNullException(nameof(createFunc));
             if (maxSize <= 0) ThrowHelper.ThrowArgumentException($"{nameof(maxSize)} must be greater than 0");
 
-            _pool = new ConcurrentBag<T>();
+            _pool = new ConcurrentStack<T>();
             _createFunc = createFunc;
             _actionOnGet = actionOnGet;
             _actionOnRelease = actionOnRelease;
@@ -83,7 +85,7 @@ public SwiftObjectPool(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T Rent()
         {
-            if (_pool.TryTake(out var obj))
+            if (_pool.TryPop(out var obj))
             {
                 _actionOnGet?.Invoke(obj);
                 return obj;
@@ -118,7 +120,7 @@ public void Release(T element)
             _actionOnRelease?.Invoke(element);
 
             if (_pool.Count < _maxSize)
-                _pool.Add(element);
+                _pool.Push(element);
             else
             {
                 _actionOnDestroy?.Invoke(element);
@@ -131,7 +133,10 @@ public void Release(T element)
         /// </summary>
         public void Clear()
         {
-            while (_pool.TryTake(out var obj))
+            if (_disposed)
+                return;
+
+            while (_pool.TryPop(out var obj))
                 _actionOnDestroy?.Invoke(obj);
 
             CountAll = 0;
@@ -141,8 +146,27 @@ public void Clear()
 
         #region IDisposable Implementation
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Dispose() => Clear();
+        /// <summary>
+        /// Releases all resources used by the SwiftArrayPool.
+        /// It is important to call Dispose() to release pooled arrays, preventing potential memory leaks.
+        /// </summary>
+        public void Dispose()
+        {
+            OnDispose();
+            GC.SuppressFinalize(this);  // Avoids calling the finalizer if already disposed.
+        }
+
+        private void OnDispose()
+        {
+            if (_disposed) 
+                return;
+
+            _disposed = true;
+
+            _pool.Clear();
+        }
+
+        ~SwiftObjectPool() => OnDispose();  // Called by GC if Dispose() wasn't called explicitly.
 
         #endregion
     }