Merge pull request #156 from cnblogs/use-ConcurrentStack

Replace InterlockedStack with ConcurrentStack

Enyim.Caching/InterlockedStack.cs

@@ -3,77 +3,78 @@
 
 namespace Enyim.Collections
 {
-	/// <summary>
-	/// Implements a non-locking stack.
-	/// </summary>
-	/// <typeparam name="TItem"></typeparam>
-	public class InterlockedStack<TItem>
-	{
-		private Node head;
+    /// <summary>
+    /// Implements a non-locking stack.
+    /// </summary>
+    /// <typeparam name="TItem"></typeparam>
+    [Obsolete]
+    public class InterlockedStack<TItem>
+    {
+        private Node head;
 
-		public InterlockedStack()
-		{
-			this.head = new Node(default(TItem));
-		}
+        public InterlockedStack()
+        {
+            this.head = new Node(default(TItem));
+        }
 
-		public void Push(TItem item)
-		{
-			var node = new Node(item);
+        public void Push(TItem item)
+        {
+            var node = new Node(item);
 
-			do { node.Next = this.head.Next; }
-			while (Interlocked.CompareExchange(ref this.head.Next, node, node.Next) != node.Next);
-		}
+            do { node.Next = this.head.Next; }
+            while (Interlocked.CompareExchange(ref this.head.Next, node, node.Next) != node.Next);
+        }
 
-		public bool TryPop(out TItem value)
-		{
-			value = default(TItem);
-			Node node;
+        public bool TryPop(out TItem value)
+        {
+            value = default(TItem);
+            Node node;
 
-			do
-			{
-				node = head.Next;
-				if (node == null) return false;
-			}
-			while (Interlocked.CompareExchange(ref head.Next, node.Next, node) != node);
+            do
+            {
+                node = head.Next;
+                if (node == null) return false;
+            }
+            while (Interlocked.CompareExchange(ref head.Next, node.Next, node) != node);
 
-			value = node.Value;
+            value = node.Value;
 
-			return true;
-		}
+            return true;
+        }
 
-		#region [ Node                        ]
+        #region [ Node                        ]
 
-		private class Node
-		{
-			public readonly TItem Value;
-			public Node Next;
+        private class Node
+        {
+            public readonly TItem Value;
+            public Node Next;
 
-			public Node(TItem value)
-			{
-				this.Value = value;
-			}
-		}
+            public Node(TItem value)
+            {
+                this.Value = value;
+            }
+        }
 
-		#endregion
-	}
+        #endregion
+    }
 }
 
 #region [ License information          ]
 /* ************************************************************
- * 
+ *
  *    Copyright (c) 2010 Attila Kiskó, enyim.com
- *    
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
- *    
+ *
  *        http://www.apache.org/licenses/LICENSE-2.0
- *    
+ *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
+ *
  * ************************************************************/
 #endregion

Enyim.Caching/Memcached/MemcachedNode.cs

@@ -5,6 +5,7 @@
 using Enyim.Collections;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -266,7 +267,7 @@ private class InternalPoolImpl : IDisposable
             /// <summary>
             /// A list of already connected but free to use sockets
             /// </summary>
-            private InterlockedStack<PooledSocket> _freeItems;
+            private ConcurrentStack<PooledSocket> _freeItems;
 
             private bool isDisposed;
             private bool isAlive;
@@ -307,7 +308,7 @@ internal InternalPoolImpl(
                 this.maxItems = config.MaxPoolSize;
 
                 _semaphore = new SemaphoreSlim(maxItems, maxItems);
-                _freeItems = new InterlockedStack<PooledSocket>();
+                _freeItems = new ConcurrentStack<PooledSocket>();
 
                 _logger = logger;
                 _isDebugEnabled = _logger.IsEnabled(LogLevel.Debug);