code: @Override
      public final int size()
      {
          // Read consumer first, this is important because if the producer is node is 'older' than the consumer
          // the consumer may overtake it (consume past it) invalidating the 'snapshot' notion of size.
          LinkedQueueNode<E> chaserNode = lvConsumerNode();
          LinkedQueueNode<E> producerNode = lvProducerNode();
          int size = 0;
          // must chase the nodes all the way to the producer node, but there's no need to count beyond expected head.
          while (chaserNode != producerNode && // don't go passed producer node
              chaserNode != null && // stop at last node
              size < Integer.MAX_VALUE) // stop at max int
          {
              LinkedQueueNode<E> next;
              next = chaserNode.lvNext();
              // check if this node has been consumed, if so return what we have
              if (next == chaserNode)
              {
                  return size;
              }
              chaserNode = next;
              size++;
          }
          return size;
      }
docs: {@inheritDoc} <br>
  <p>
  IMPLEMENTATION NOTES:<br>
  This is an O(n) operation as we run through all the nodes and count them.<br>
  The accuracy of the value returned by this method is subject to races with producer/consumer threads. In
  particular when racing with the consumer thread this method may under estimate the size.<br>
  
  @see java.util.Queue#size()