Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Code cleanup and properly synchronized.

This commit is contained in:
Simone Bordet 2011-08-16 18:26:37 +02:00
parent ee1afa5e97
commit faaeabd243
1 changed files with 161 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
jetty-util/src/main/java/org/eclipse/jetty/util/ArrayQueue.java
View File

@ -18,8 +18,9 @@ import java.util.NoSuchElementException;
import java.util.Queue; import java.util.Queue;
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
/** Queue backed by circular array. /**
* * Queue backed by circular array.
* <p/>
* This partial Queue implementation (also with {@link #remove()} for stack operation) * This partial Queue implementation (also with {@link #remove()} for stack operation)
* is backed by a growable circular array. * is backed by a growable circular array.
* *
@ -27,49 +28,50 @@ import java.util.Queue;
*/ */
public class ArrayQueue<E> extends AbstractList<E> implements Queue<E> public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
{ {
public final int DEFAULT_CAPACITY=64; public static final int DEFAULT_CAPACITY = 64;
public final int DEFAULT_GROWTH=32; public static final int DEFAULT_GROWTH = 32;
protected Object _lock=this;
protected final Object _lock;
protected final int _growCapacity;
protected Object[] _elements; protected Object[] _elements;
protected int _nextE; protected int _nextE;
protected int _nextSlot; protected int _nextSlot;
protected volatile int _size; protected int _size;
protected int _growCapacity;
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public ArrayQueue() public ArrayQueue()
{ {
_elements=new Object[64]; this(DEFAULT_CAPACITY, -1);
_growCapacity=32;
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public ArrayQueue(int capacity) public ArrayQueue(int capacity)
{ {
_elements=new Object[capacity]; this(capacity, -1);
_growCapacity=-1;
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public ArrayQueue(int initCapacity,int growBy) public ArrayQueue(int initCapacity, int growBy)
{ {
_elements=new Object[initCapacity]; this(initCapacity, growBy, null);
_growCapacity=growBy;
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public ArrayQueue(int initCapacity,int growBy,Object lock) public ArrayQueue(int initCapacity, int growBy, Object lock)
{ {
_elements=new Object[initCapacity]; _lock = lock == null ? this : lock;
_growCapacity=growBy; _growCapacity = growBy;
_lock=lock; _elements = new Object[initCapacity];
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public int getCapacity() public int getCapacity()
{
synchronized (_lock)
{ {
return _elements.length; return _elements.length;
} }
}
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
@Override @Override
@ -83,86 +85,97 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public boolean offer(E e) public boolean offer(E e)
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (_size==_elements.length && !grow()) return enqueue(e);
}
}
/* ------------------------------------------------------------ */
private boolean enqueue(E e)
{
if (_size == _elements.length && !grow())
return false; return false;
_size++; _size++;
_elements[_nextSlot++]=e; _elements[_nextSlot++] = e;
if (_nextSlot==_elements.length) if (_nextSlot == _elements.length)
_nextSlot=0; _nextSlot = 0;
}
return true; return true;
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
/** /**
* Add without synchronization or bounds checking * Add without synchronization or bounds checking
*
* @param e the element to add
* @see #add(Object) * @see #add(Object)
*/ */
public void addUnsafe(E e) public void addUnsafe(E e)
{ {
if (_size==_elements.length && !grow()) if (!enqueue(e))
throw new IllegalStateException("Full"); throw new IllegalStateException("Full");
_size++;
_elements[_nextSlot++]=e;
if (_nextSlot==_elements.length)
_nextSlot=0;
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public E element() public E element()
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (_size==0) if (isEmpty())
throw new NoSuchElementException(); throw new NoSuchElementException();
return (E)_elements[_nextE]; return at(_nextE);
} }
} }
@SuppressWarnings("unchecked")
private E at(int index)
{
return (E)_elements[index];
}
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public E peek() public E peek()
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (_size==0) if (isEmpty())
return null; return null;
return (E)_elements[_nextE]; return at(_nextE);
} }
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public E poll() public E poll()
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (_size==0) if (_size == 0)
return null; return null;
E e = (E)_elements[_nextE]; return dequeue();
_elements[_nextE]=null;
_size--;
if (++_nextE==_elements.length)
_nextE=0;
return e;
} }
} }
/* ------------------------------------------------------------ */
private E dequeue()
{
E e = at(_nextE);
_elements[_nextE] = null;
_size--;
if (++_nextE == _elements.length)
_nextE = 0;
return e;
}
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
public E remove() public E remove()
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (_size==0) if (_size == 0)
throw new NoSuchElementException(); throw new NoSuchElementException();
E e = (E)_elements[_nextE]; return dequeue();
_elements[_nextE]=null;
_size--;
if (++_nextE==_elements.length)
_nextE=0;
return e;
} }
} }
@ -170,11 +183,11 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
@Override @Override
public void clear() public void clear()
{ {
synchronized(_lock) synchronized (_lock)
{ {
_size=0; _size = 0;
_nextE=0; _nextE = 0;
_nextSlot=0; _nextSlot = 0;
} }
} }
@ -182,61 +195,65 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
@Override @Override
public boolean isEmpty() public boolean isEmpty()
{ {
synchronized(_lock) synchronized (_lock)
{ {
return _size==0; return _size == 0;
} }
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
@Override @Override
public int size() public int size()
{
synchronized (_lock)
{ {
return _size; return _size;
} }
}
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
@Override @Override
public E get(int index) public E get(int index)
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (index<0 || index>=_size) if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")"); throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
int i = (_nextE+index)%_elements.length; return getUnsafe(index);
return (E)_elements[i];
} }
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
/** /**
* Get without synchronization or bounds checking. * Get without synchronization or bounds checking.
*
* @param index index of the element to return
* @return the element at the specified index
* @see #get(int) * @see #get(int)
*/ */
public E getUnsafe(int index) public E getUnsafe(int index)
{ {
int i = (_nextE+index)%_elements.length; int i = (_nextE + index) % _elements.length;
return (E)_elements[i]; return at(i);
} }
/* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */
@Override @Override
public E remove(int index) public E remove(int index)
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (index<0 || index>=_size) if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")"); throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
int i = (_nextE+index)%_elements.length; int i = (_nextE + index) % _elements.length;
E old=(E)_elements[i]; E old = at(i);
if (i<_nextSlot) if (i < _nextSlot)
{ {
// 0 _elements.length // 0 _elements.length
// _nextE........._nextSlot // _nextE........._nextSlot
System.arraycopy(_elements,i+1,_elements,i,_nextSlot-i); System.arraycopy(_elements, i + 1, _elements, i, _nextSlot - i);
_nextSlot--; _nextSlot--;
_size--; _size--;
} }
@ -244,15 +261,15 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
{ {
// 0 _elements.length // 0 _elements.length
// ......_nextSlot _nextE.......... // ......_nextSlot _nextE..........
System.arraycopy(_elements,i+1,_elements,i,_elements.length-i-1); System.arraycopy(_elements, i + 1, _elements, i, _elements.length - i - 1);
if (_nextSlot>0) if (_nextSlot > 0)
{ {
_elements[_elements.length-1]=_elements[0]; _elements[_elements.length - 1] = _elements[0];
System.arraycopy(_elements,1,_elements,0,_nextSlot-1); System.arraycopy(_elements, 1, _elements, 0, _nextSlot - 1);
_nextSlot--; _nextSlot--;
} }
else else
_nextSlot=_elements.length-1; _nextSlot = _elements.length - 1;
_size--; _size--;
} }
@ -265,16 +282,16 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
@Override @Override
public E set(int index, E element) public E set(int index, E element)
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (index<0 || index>=_size) if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")"); throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
int i = _nextE+index; int i = _nextE + index;
if (i>=_elements.length) if (i >= _elements.length)
i-=_elements.length; i -= _elements.length;
E old=(E)_elements[i]; E old = at(i);
_elements[i]=element; _elements[i] = element;
return old; return old;
} }
} }
@ -283,72 +300,75 @@ public class ArrayQueue<E> extends AbstractList<E> implements Queue<E>
@Override @Override
public void add(int index, E element) public void add(int index, E element)
{ {
synchronized(_lock) synchronized (_lock)
{ {
if (index<0 || index>_size) if (index < 0 || index > _size)
throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")"); throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
if (_size==_elements.length && !grow()) if (_size == _elements.length && !grow())
throw new IllegalStateException("Full"); throw new IllegalStateException("Full");
if (index==_size) if (index == _size)
{ {
add(element); add(element);
} }
else else
{ {
int i = _nextE+index; int i = _nextE + index;
if (i>=_elements.length) if (i >= _elements.length)
i-=_elements.length; i -= _elements.length;
_size++; _size++;
_nextSlot++; _nextSlot++;
if (_nextSlot==_elements.length) if (_nextSlot == _elements.length)
_nextSlot=0; _nextSlot = 0;
if (i<_nextSlot) if (i < _nextSlot)
{ {
// 0 _elements.length // 0 _elements.length
// _nextE.....i..._nextSlot // _nextE.....i..._nextSlot
// 0 _elements.length // 0 _elements.length
// ..i..._nextSlot _nextE.......... // ..i..._nextSlot _nextE..........
System.arraycopy(_elements,i,_elements,i+1,_nextSlot-i); System.arraycopy(_elements, i, _elements, i + 1, _nextSlot - i);
_elements[i]=element; _elements[i] = element;
} }
else else
{ {
// 0 _elements.length // 0 _elements.length
// ......_nextSlot _nextE.....i.... // ......_nextSlot _nextE.....i....
if (_nextSlot>0) if (_nextSlot > 0)
{ {
System.arraycopy(_elements,0,_elements,1,_nextSlot); System.arraycopy(_elements, 0, _elements, 1, _nextSlot);
_elements[0]=_elements[_elements.length-1]; _elements[0] = _elements[_elements.length - 1];
} }
System.arraycopy(_elements,i,_elements,i+1,_elements.length-i-1); System.arraycopy(_elements, i, _elements, i + 1, _elements.length - i - 1);
_elements[i]=element; _elements[i] = element;
} }
} }
} }
} }
/* ------------------------------------------------------------ */
protected boolean grow() protected boolean grow()
{ {
if (_growCapacity<=0) synchronized (_lock)
{
if (_growCapacity <= 0)
return false; return false;
Object[] elements=new Object[_elements.length+_growCapacity]; Object[] elements = new Object[_elements.length + _growCapacity];
int split=_elements.length-_nextE; int split = _elements.length - _nextE;
if (split>0) if (split > 0)
System.arraycopy(_elements,_nextE,elements,0,split); System.arraycopy(_elements, _nextE, elements, 0, split);
if (_nextE!=0) if (_nextE != 0)
System.arraycopy(_elements,0,elements,split,_nextSlot); System.arraycopy(_elements, 0, elements, split, _nextSlot);
_elements=elements; _elements = elements;
_nextE=0; _nextE = 0;
_nextSlot=_size; _nextSlot = _size;
return true; return true;
} }
}
} }