Example #1
0
            public bool Dequeue(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);
                            }
                            SyncMethods.CAS <SingleLinkNode <T> >(ref tail, oldTail, oldHeadNext);
                        }

                        else
                        {
                            item             = oldHeadNext.Item;
                            haveAdvancedHead =
                                SyncMethods.CAS <SingleLinkNode <T> >(ref head, oldHead, oldHeadNext);
                        }
                    }
                }
                return(true);
            }
Example #2
0
            public void Enqueue(T item)
            {
                SingleLinkNode <T> oldTail = null;
                SingleLinkNode <T> oldTailNext;

                SingleLinkNode <T> newNode = new SingleLinkNode <T>();

                newNode.Item = item;

                bool newNodeWasAdded = false;

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

                    if (tail == oldTail)
                    {
                        if (oldTailNext == null)
                        {
                            newNodeWasAdded = SyncMethods.CAS <SingleLinkNode <T> >(ref tail.Next, null, newNode);
                        }
                        else
                        {
                            SyncMethods.CAS <SingleLinkNode <T> >(ref tail, oldTail, oldTailNext);
                        }
                    }
                }

                SyncMethods.CAS <SingleLinkNode <T> >(ref tail, oldTail, newNode);
            }
Example #3
0
 public void Push(SingleLinkNode <T> newNode)
 {
     newNode.Item = default(T);
     do
     {
         newNode.Next = head.Next;
     } while (!SyncMethods.CAS <SingleLinkNode <T> >(ref head.Next, newNode.Next, newNode));
     return;
 }
Example #4
0
            public void Push(T item)
            {
                SingleLinkNode <T> newNode = new SingleLinkNode <T>();

                newNode.Item = item;
                do
                {
                    newNode.Next = head.Next;
                } while (!SyncMethods.CAS <SingleLinkNode <T> >(ref head.Next, newNode.Next, newNode));
            }
Example #5
0
 public bool Pop(out SingleLinkNode <T> node)
 {
     do
     {
         node = head.Next;
         if (node == null)
         {
             return(false);
         }
     } while (!SyncMethods.CAS <SingleLinkNode <T> >(ref head.Next, node, node.Next));
     return(true);
 }
Example #6
0
            public bool Pop(out T item)
            {
                SingleLinkNode <T> node;

                do
                {
                    node = head.Next;
                    if (node == null)
                    {
                        item = default(T);
                        return(false);
                    }
                } while (!SyncMethods.CAS <SingleLinkNode <T> >(ref head.Next, node, node.Next));
                item = node.Item;
                return(true);
            }