private void removeFromList(final Node node) {
final Node next = node.mNext;
final Node previous = node.mPrevious;
if (previous != null) {
previous.mNext = next;
} else {
mHead = next;
}
if (next != null) {
next.mPrevious = previous;
} else {
mTail = previous;
}
node.mNext = null;
node.mPrevious = null;
}
private void addToHead(final Node node) {
if (mHead == null) {
mHead = node;
mTail = node;
} else {
node.mNext = mHead;
mHead.mPrevious = node;
mHead = node;
}
}
private void removeTail() {
mMap.remove(mTail.mKey);
if (mTail == mHead) {
mHead = null;
mTail = null;
} else {
mTail = mTail.mPrevious;
mTail.mNext = null;
}
}
/** Clears out all waiters and interrupts them. */
void clear() {
Node node = mHead;
while (node != null) {
Thread waiter = node.mWaiter;
if (waiter != null) {
waiter.interrupt();
}
node.mPrev = null;
Node next = node.mNext;
node.mNext = null;
node = next;
}
mHead = null;
mTail = null;
}
final void remove(WaitQueue queue) {
Node prev = mPrev;
Node next = mNext;
if (prev == null) {
if ((queue.mHead = next) == null) {
queue.mTail = null;
} else {
next.mPrev = null;
}
} else {
if ((prev.mNext = next) == null) {
queue.mTail = prev;
} else {
next.mPrev = prev;
}
mPrev = null;
}
mNext = null;
}
/**
* Wait for signal with no spurious wakeup. Exclusive latch must be held, which is still held when
* method returns.
*
* @param node newly allocated node
* @param nanosTimeout relative nanosecond time to wait; infinite if <0
* @param nanosEnd absolute nanosecond time to wait until; used only with >0 timeout
* @return -1 if interrupted, 0 if timed out, 1 if signaled
*/
int await(Latch latch, Node node, long nanosTimeout, long nanosEnd) {
node.mWaiter = Thread.currentThread();
Node tail = mTail;
if (tail == null) {
mHead = node;
} else {
tail.mNext = node;
node.mPrev = tail;
}
mTail = node;
if (nanosTimeout < 0) {
while (true) {
latch.releaseExclusive();
LockSupport.park();
latch.acquireExclusive();
int state = node.resumed(this);
if (state != 0) {
return state;
}
}
} else {
while (true) {
latch.releaseExclusive();
LockSupport.parkNanos(nanosTimeout);
latch.acquireExclusive();
int state = node.resumed(this);
if (state != 0) {
return state;
}
if (nanosTimeout == 0 || (nanosTimeout = nanosEnd - System.nanoTime()) <= 0) {
node.remove(this);
return 0;
}
}
}
}
