Пример #1
0
        /// <summary>
        /// Removes and returns the object at the beginning of the queue.
        /// </summary>
        /// <param name="item">
        /// when the method returns, contains the object removed from the beginning of the queue,
        /// if the queue is not empty; otherwise it is the default value for the element type
        /// </param>
        /// <returns>
        /// true if an object from removed from the beginning of the queue;
        /// false if the queue is empty
        /// </returns>
        public bool TryDequeue(out T item)
        {
            item = default(T);
            bool flag = false;

            while (!flag)
            {
                SingleLinkNode <T> head = _head;
                SingleLinkNode <T> tail = _tail;
                SingleLinkNode <T> next = head.Next;
                if (head == _head)
                {
                    if (head == tail)
                    {
                        if (next == null)
                        {
                            return(false);
                        }
                        Interlocked.CompareExchange(ref _tail, next, tail);
                    }
                    else
                    {
                        item = next.Item;
                        flag = Interlocked.CompareExchange(ref _head, next, head) == head;
                    }
                }
            }

            Interlocked.Decrement(ref _count);
            return(true);
        }
Пример #2
0
        /// <summary>
        /// Adds an object to the end of the queue.
        /// </summary>
        /// <param name="item">the object to add to the queue</param>
        public void Enqueue(T item)
        {
            SingleLinkNode <T> oldTail = null;
            SingleLinkNode <T> oldTailNext;

            var newNode = new SingleLinkNode <T> {
                Item = item
            };

            bool newNodeWasAdded = false;

            while (!newNodeWasAdded)
            {
                oldTail     = _tail;
                oldTailNext = oldTail.Next;

                if (_tail == oldTail)
                {
                    if (oldTailNext == null)
                    {
                        newNodeWasAdded =
                            Interlocked.CompareExchange <SingleLinkNode <T> >(ref _tail.Next, newNode, null) == null;
                    }
                    else
                    {
                        Interlocked.CompareExchange <SingleLinkNode <T> >(ref _tail, oldTailNext, oldTail);
                    }
                }
            }

            Interlocked.CompareExchange <SingleLinkNode <T> >(ref _tail, newNode, oldTail);
            Interlocked.Increment(ref _count);
        }
Пример #3
0
        /// <summary>Adds an object to the end of the queue.</summary>
        /// <param name="item">the object to add to the queue</param>
        public void Enqueue(T item)
        {
            SingleLinkNode <T> comparand      = null;
            SingleLinkNode <T> singleLinkNode = new SingleLinkNode <T>
            {
                Item = item
            };
            bool flag = false;

            while (!flag)
            {
                comparand = _tail;
                SingleLinkNode <T> next = comparand.Next;
                if (_tail == comparand)
                {
                    if (next == null)
                    {
                        flag = Interlocked.CompareExchange(ref _tail.Next, singleLinkNode,
                                                           null) == null;
                    }
                    else
                    {
                        Interlocked.CompareExchange(ref _tail, next, comparand);
                    }
                }
            }

            Interlocked.CompareExchange(ref _tail, singleLinkNode, comparand);
            Interlocked.Increment(ref _count);
        }
Пример #4
0
 /// <summary>Inserts an object at the top of the stack.</summary>
 /// <param name="item">the object to push onto the stack</param>
 public void Push(T item)
 {
   SingleLinkNode<T> singleLinkNode = new SingleLinkNode<T>();
   singleLinkNode.Item = item;
   do
   {
     singleLinkNode.Next = _head.Next;
   } while(Interlocked.CompareExchange(ref _head.Next, singleLinkNode,
             singleLinkNode.Next) != singleLinkNode.Next);
 }
Пример #5
0
        /// <summary>
        /// Inserts an object at the top of the stack.
        /// </summary>
        /// <param name="item">the object to push onto the stack</param>
        public void Push(T item)
        {
            SingleLinkNode <T> newNode = new SingleLinkNode <T>();

            newNode.Item = item;

            do
            {
                newNode.Next = _head.Next;
            } while (Interlocked.CompareExchange <SingleLinkNode <T> >(ref _head.Next, newNode, newNode.Next) != newNode.Next);
        }
Пример #6
0
        /// <summary>
        /// Returns an enumerator that iterates through the queue.
        /// </summary>
        /// <returns>an enumerator for the queue</returns>
        public IEnumerator <T> GetEnumerator()
        {
            SingleLinkNode <T> currentNode = _head;

            while (currentNode.Item != null)
            {
                yield return(currentNode.Item);

                if ((currentNode = currentNode.Next) == null)
                {
                    break;
                }
            }
        }
Пример #7
0
        /// <summary>Clears the queue.</summary>
        /// <remarks>This method is not thread-safe.</remarks>
        public void Clear()
        {
            SingleLinkNode <T> singleLinkNode1 = _head;

            while (singleLinkNode1 != null)
            {
                SingleLinkNode <T> singleLinkNode2 = singleLinkNode1;
                singleLinkNode1      = singleLinkNode1.Next;
                singleLinkNode2.Item = default(T);
                singleLinkNode2.Next = null;
            }

            _head  = new SingleLinkNode <T>();
            _tail  = _head;
            _count = 0;
        }
Пример #8
0
        /// <summary>Clears the queue.</summary>
        /// <remarks>This method is not thread-safe.</remarks>
        public void Clear()
        {
            SingleLinkNode <T> singleLinkNode1 = this._head;

            while (singleLinkNode1 != null)
            {
                SingleLinkNode <T> singleLinkNode2 = singleLinkNode1;
                singleLinkNode1      = singleLinkNode1.Next;
                singleLinkNode2.Item = default(T);
                singleLinkNode2.Next = (SingleLinkNode <T>)null;
            }

            this._head  = new SingleLinkNode <T>();
            this._tail  = this._head;
            this._count = 0;
        }
Пример #9
0
        /// <summary>
        /// Clears the queue.
        /// </summary>
        /// <remarks>This method is not thread-safe.</remarks>
        public void Clear()
        {
            SingleLinkNode <T> tempNode;
            SingleLinkNode <T> currentNode = _head;

            while (currentNode != null)
            {
                tempNode    = currentNode;
                currentNode = currentNode.Next;

                tempNode.Item = default(T);
                tempNode.Next = null;
            }

            _head  = new SingleLinkNode <T>();
            _tail  = _head;
            _count = 0;
        }
Пример #10
0
        /// <summary>
        /// Returns an enumerator that iterates through the queue.
        /// </summary>
        /// <returns>an enumerator for the queue</returns>
        public IEnumerator <T> GetEnumerator()
        {
            SingleLinkNode <T> currentNode = _head;

            do
            {
                if (currentNode.Item == null)
                {
                    yield break;
                }
                else
                {
                    yield return(currentNode.Item);
                }
            }while ((currentNode = currentNode.Next) != null);

            yield break;
        }
Пример #11
0
        /// <summary>
        /// Removes and returns the object at the beginning of the queue.
        /// </summary>
        /// <param name="item">
        /// when the method returns, contains the object removed from the beginning of the queue,
        /// if the queue is not empty; otherwise it is the default value for the element type
        /// </param>
        /// <returns>
        /// true if an object from removed from the beginning of the queue;
        /// false if the queue is empty
        /// </returns>
        public bool TryDequeue(out T item)
        {
            item = default(T);
            SingleLinkNode <T> oldHead = null;

            bool haveAdvancedHead = false;

            while (!haveAdvancedHead)
            {
                oldHead = _head;
                SingleLinkNode <T> oldTail     = _tail;
                SingleLinkNode <T> oldHeadNext = oldHead.Next;

                if (oldHead == _head)
                {
                    if (oldHead == oldTail)
                    {
                        if (oldHeadNext == null)
                        {
                            return(false);
                        }

                        Interlocked.CompareExchange <SingleLinkNode <T> >(ref _tail, oldHeadNext, oldTail);
                    }

                    else
                    {
                        item             = oldHeadNext.Item;
                        haveAdvancedHead =
                            Interlocked.CompareExchange <SingleLinkNode <T> >(ref _head, oldHeadNext, oldHead) == oldHead;
                    }
                }
            }

            Interlocked.Decrement(ref _count);
            return(true);
        }
Пример #12
0
 /// <summary>Default constructors.</summary>
 public LockFreeStack()
 {
     this._head = new SingleLinkNode <T>();
 }
Пример #13
0
 /// <summary>Default constructor.</summary>
 public LockfreeQueue()
 {
     _head = new SingleLinkNode <T>();
     _tail = _head;
 }
Пример #14
0
 /// <summary>Default constructor.</summary>
 public LockfreeQueue()
 {
     this._head = new SingleLinkNode <T>();
     this._tail = this._head;
 }