环形队列问题

[曹操不会飞]

请编写一个环形队列类，要求支持多线程读写，读写长度可参数化，队列长度限制在 256 个单元，读写策越为先进先出。当队列发生溢出时，依照先进先出的策略覆盖最早进入队列的元素。
求大神解读啊

[安特矮油]

那边回复你了
http://topic.csdn.net/u/20120913/16/1559e480-1dc6-4061-bedd-1885956fd1b0.html?13215

[冰思雨]

双向链表组成环状队列。

public class CycleQueue<E> {

	public static int DEFAULT_CAPACITY = 256;
	class Entry{
		Entry previous;
		Entry next;
		E element;
	}
	
	private Entry header;
	private int capacity;
	private int size=0;
	
	public CycleQueue(){
		this(DEFAULT_CAPACITY);
	}
	
	public CycleQueue(int capacity){
		this.capacity=capacity;
		header = new Entry();
		header.next=header;
		header.previous=header;
	}
	
	/**向队列里加入元素
	 * @param elem 所要添加的元素
	 * @return 当且仅当队列溢出时返回被替换的元素，其他情况返回<code>null</code>。
	 */
	public synchronized E offer(E elem){
		if(size>=capacity){
			E e = header.next.element;
			header.element = elem;
			header = header.next;
			header.element=null;
			return e;
		}
		Entry e = new Entry();
		e.element = elem;
		e.previous = header.previous;
		e.next = header;
		e.previous.next = e;
		header.previous = e;
		size++;
		return null;
	}
	
	/**从队列里取得元素
	 * @return 当队列为空时，返回<code>null</code>
	 */
	public synchronized E poll(){
		if(size<=0){
			return null;
		}
		Entry e = header.next;
		header.next = e.next;
		e.next.previous = header;
		size--;
		return e.element;
	}
	
	/**
	 * 获得队列的容量
	 */
	public int getCapacity(){
		return capacity;
	}
	
	/**
	 * 获得队列当前所含元素的个数
	 */
	public int size() {
		return size;
	}

	/**
	 * 测试用例
	 */
	public static void main(String[] args) {
		CycleQueue<Integer> queue = new CycleQueue<Integer>(5);
		System.out.println(queue.offer(Integer.valueOf(0)));
		System.out.println(queue.offer(Integer.valueOf(1)));
		System.out.println(queue.offer(Integer.valueOf(2)));
		System.out.println(queue.poll());
		System.out.println(queue.poll());
		for(int i=1;i<=5;i++){
			queue.offer(i);
		}
		System.out.println(queue.offer(10));
		System.out.println(queue.poll());
		System.out.println(queue.poll());
	}

}