public PriorityLinkedListImpl(final int priorities) { levels = (LinkedListImpl<T>[]) Array.newInstance(LinkedListImpl.class, priorities); for (int i = 0; i < priorities; i++) { levels[i] = new LinkedListImpl<>(); } }
@Override public void addTail(E e) { if (size == 0) { addHead(e); } else { Node<E> node = Node.with(e); node.prev = tail; tail.next = node; tail = node; size++; } }
@Override public void addTail(final T t, final int priority) { checkHighest(priority); levels[priority].addTail(t); exclusiveIncrementSize(1); }
@Override public T poll() { T t = null; // We are just using a simple prioritization algorithm: // Highest priority refs always get returned first. // This could cause starvation of lower priority refs. // TODO - A better prioritization algorithm for (int i = highestPriority; i >= 0; i--) { LinkedListImpl<T> ll = levels[i]; if (ll.size() != 0) { t = ll.poll(); if (t != null) { exclusiveIncrementSize(-1); if (ll.size() == 0) { if (highestPriority == i) { highestPriority--; } } } break; } } return t; }
list.addTail(i); assertEquals(num, list.size()); list.clear(); assertEquals(0, list.size()); assertNull(list.poll()); LinkedListIterator<Integer> iter = list.iterator(); list.addTail(i); assertEquals(num, list.size()); iter = list.iterator(); assertEquals(i, list.poll().intValue()); assertNull(list.poll()); assertEquals(0, list.size());
@Test public void testAddHeadAndTail() { int num = 10; for (int i = 0; i < num; i++) { list.addHead(i); } for (int i = num; i < num * 2; i++) { list.addTail(i); } for (int i = num * 2; i < num * 3; i++) { list.addHead(i); } for (int i = num * 3; i < num * 4; i++) { list.addTail(i); } for (int i = num * 3 - 1; i >= num * 2; i--) { assertEquals(i, list.poll().intValue()); } for (int i = num - 1; i >= 0; i--) { assertEquals(i, list.poll().intValue()); } for (int i = num; i < num * 2; i++) { assertEquals(i, list.poll().intValue()); } for (int i = num * 3; i < num * 4; i++) { assertEquals(i, list.poll().intValue()); } }
@Test public void testRemoveHeadAndTail3() { LinkedListIterator<Integer> iter = list.iterator(); int num = 10; for (int i = 0; i < num; i++) { if (i % 2 == 0) { list.addHead(i); } else { list.addTail(i); } assertEquals(1, list.size()); assertTrue(iter.hasNext()); assertEquals(i, iter.next().intValue()); iter.remove(); } }
LinkedListImpl<MyObject> objs = new LinkedListImpl<>(); objs.addHead(new MyObject(i)); LinkedListIterator<MyObject> iter = objs.iterator(); iter = objs.iterator(); objs.clear();
private synchronized void addIter(Iterator iter) { if (numIters == iters.length) { resize(2 * numIters); } iters[nextIndex++] = iter; numIters++; }
public LinkedListImpl() { iters = createIteratorArray(INITIAL_ITERATOR_ARRAY_SIZE); }
@Test public void testRemoveInTurn() { LinkedListIterator<Integer> iter = list.iterator(); int num = 10; for (int i = 0; i < num; i++) { list.addTail(i); } for (int i = 0; i < num; i++) { assertTrue(iter.hasNext()); assertEquals(i, iter.next().intValue()); iter.remove(); } assertFalse(iter.hasNext()); assertEquals(0, list.size()); }
@Override public void clear() { for (LinkedListImpl<T> list : levels) { list.clear(); } exclusiveSetSize(0); }
LinkedListImpl<MyObject> objs = new LinkedListImpl<>(); objs.addTail(new MyObject()); LinkedListIterator<MyObject> iter = objs.iterator(); objs.addTail(new MyObject());
@Override public E poll() { Node<E> ret = head.next; if (ret != null) { removeAfter(head); return ret.val(); } else { return null; } }
private void removeAfter(Node<E> node) { Node<E> toRemove = node.next; node.next = toRemove.next; if (toRemove.next != null) { toRemove.next.prev = node; } if (toRemove == tail) { tail = node; } size--; if (toRemove.iterCount != 0) { LinkedListImpl.this.nudgeIterators(toRemove); } //Help GC - otherwise GC potentially has to traverse a very long list to see if elements are reachable, this can result in OOM //https://jira.jboss.org/browse/HORNETQ-469 toRemove.next = toRemove.prev = null; }
@Override public T poll() { T t = null; // We are just using a simple prioritization algorithm: // Highest priority refs always get returned first. // This could cause starvation of lower priority refs. // TODO - A better prioritization algorithm for (int i = highestPriority; i >= 0; i--) { LinkedListImpl<T> ll = levels[i]; if (ll.size() != 0) { t = ll.poll(); if (t != null) { exclusiveIncrementSize(-1); if (ll.size() == 0) { if (highestPriority == i) { highestPriority--; } } } break; } } return t; }