单线程无锁读写缓存

import java.util.Arrays;

/**
 * 创建一个循环队列（环形缓冲、RingBuffer），实际元素存在一个数组中，操作数组的指针，不移动元素
 * <p/>
 * 需要说明是：支持单线程无锁读与写
 */
public class CircleQueue<T>
{
    //      循环队列 （数组）默认大小
    private final int DEFAULT_SIZE = 1000;
    //      (循环队列)数组的容量
    public int capacity;
    //      数组：保存循环队列的元素
    public Object[] elementData;
    //      队头(先见先出)
    public int head = 0;
    //      队尾
    public int tail = 0;
    //      以循环队列 默认大小创建空循环队列

    public CircleQueue()
    {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    public CircleQueue(final int initSize)
    {
        capacity = initSize;
        elementData = new Object[capacity];
    }

    /**
     * 获取循环队列的大小(包含元素的个数)
     */
    public int size()
    {
        if (isEmpty())
        {
            return 0;
        } else if (isFull())
        {
            return capacity;
        } else
        {
            return tail + 1;
        }
    }

    /**
     * 插入队尾一个元素
     */
    public void add(final T element)
    {
        if (isEmpty())
        {
            elementData[0] = element;
        } else if (isFull())
        {
            elementData[head] = element;
            head++;
            tail++;
            head = head == capacity ? 0 : head;
            tail = tail == capacity ? 0 : tail;
        } else
        {
            elementData[tail + 1] = element;
            tail++;
        }
    }

    public boolean isEmpty()
    {
        return tail == head && tail == 0 && elementData[tail] == null;
    }

    public boolean isFull()
    {
        return head != 0 && head - tail == 1 || head == 0 && tail == capacity - 1;
    }

    public void clear()
    {
        Arrays.fill(elementData, null);
        head = 0;
        tail = 0;
    }

    /**
     * @return 取 循环队列里的值（先进的index=0）
     */
    public Object[] getQueue()
    {
        final Object[] elementDataSort = new Object[capacity];
        final Object[] elementDataCopy = elementData.clone();
        if (isEmpty())
        {
        } else if (isFull())
        {
            int indexMax = capacity;
            int indexSort = 0;
            for (int i = head; i < indexMax; )
            {
                elementDataSort[indexSort] = elementDataCopy[i];
                indexSort++;
                i++;
                if (i == capacity)
                {
                    i = 0;
                    indexMax = head;
                }
            }
        } else
        {
            // elementDataSort = elementDataCopy;//用这行代码代替下面的循环，在队列刚满时候会出错
            for (int i = 0; i < tail; i++)
            {
                elementDataSort[i] = elementDataCopy[i];
            }
        }
        return elementDataSort;
    }

 
}