private Token receive0() {
Node s = new Node(null, false); // the node to append
retry:
for (; ; ) { // restart on append race
Object item = tryMatch(null, null, false);
if (item != NO_MATCH) {
s.item = item;
return new Token(s, null);
}
Node pred = tryAppend(s, false);
if (pred == null) continue retry; // lost race vs opposite mode
if (sendClosed) {
s.item = CHANNEL_CLOSED;
unsplice(pred, s);
setReceiveClosed();
return new Token(s, null);
}
requestUnpark(s, Strand.currentStrand());
return new Token(s, pred);
}
}
/**
* Removes a node from head of queue,
*
* @return the node
*/
private Node<E> extract() {
Node<E> current = head;
head = head.next;
current.item = head.item;
head.item = null;
return current;
}
/**
* Implements all queuing methods. See above for explanation.
*
* @param e the item or null for take
* @param haveData true if this is a put, else a take
* @param how NOW, ASYNC, SYNC, or TIMED
* @param nanos timeout in nanosecs, used only if mode is TIMED
* @return an item if matched, else e
* @throws NullPointerException if haveData mode but e is null
*/
private Object xfer1(Message e, boolean haveData, int how, long nanos) throws SuspendExecution {
assert how == SYNC || how == TIMED;
if (haveData && (e == null)) throw new NullPointerException();
Node s = null; // the node to append, if needed
retry:
for (; ; ) { // restart on append race
Object item = tryMatch(null, e, haveData);
if (item != NO_MATCH) return item;
if (s == null) s = new Node(e, haveData);
Node pred = tryAppend(s, haveData);
if (pred == null) continue retry; // lost race vs opposite mode
if (!haveData && sendClosed) {
s.item = CHANNEL_CLOSED;
unsplice(pred, s);
setReceiveClosed();
return CHANNEL_CLOSED;
}
return awaitMatch(s, pred, e, (how == TIMED), nanos);
}
}
public E take() throws InterruptedException {
Node<E> x;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
try {
while (count.get() == 0) notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to a non-interrupted thread
throw ie;
}
x = extract();
if (count.getAndDecrement() > 1) notEmpty.signal();
} finally {
takeLock.unlock();
}
E result = x.item;
// temporary clearence
x.item = null;
x.next = null;
return result;
}
public Item dequeue() // delete and return a random item
{
if (isEmpty()) {
throw new java.util.NoSuchElementException("RandomizedQueue is empty");
}
int index = StdRandom.uniform(0, size);
Node node = findNode(index);
Item item = node.item;
Node prevnode = node.prev;
Node nextnode = node.next;
if (prevnode != null) {
prevnode.next = nextnode;
} else {
first = nextnode;
}
if (nextnode != null) {
nextnode.prev = prevnode;
} else {
last = prevnode;
}
node.item = null;
node.next = null;
node.prev = null;
size--;
return item;
}
/**
* Will add a new item to the start of the deque. Will throw an error if an empty item is passed
* through. If this is the first item that has been added to the deque, then this will also set
* the last item in the deque to be the first.
*
* @param item The item to add to the start of the deque
*/
public void addFirst(Item item) {
if (item == null) {
throw new NullPointerException("Woah, you can't add nothing");
}
Node previousFirst = first;
first = new Node();
first.item = item;
first.previous = null;
if (previousFirst == null) {
// This is the first time something has been added to the deque
first.next = null;
} else {
first.next = previousFirst;
previousFirst.previous = first;
}
// Is this the only node in the deque?
if (last == null) {
last = first;
}
N++;
}
public void remove() {
Node<E> l = lastRet;
if (l == null) throw new IllegalStateException();
// rely on a future traversal to relink.
l.item = null;
lastRet = null;
}
/**
* Adds the item to this stack.
*
* @param item the item to add
*/
public void push(Item item) {
Node<Item> oldfirst = first;
first = new Node<Item>();
first.item = item;
first.next = oldfirst;
N++;
}
/** Add the item to the bag. */
public void add(Item item) {
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
N++;
}
public E poll() {
final AtomicInteger count = this.count;
if (count.get() == 0) return null;
Node<E> x = null;
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
if (count.get() > 0) {
x = extract();
if (count.getAndDecrement() > 1) notEmpty.signal();
}
} finally {
takeLock.unlock();
}
if (x != null) {
E result = x.item;
// temporary clearence
x.item = null;
x.next = null;
return result;
}
return null;
}
public void setNext(Node next) {
Node oldNode = (Node) pj.find(this);
Node newNode = new Node(oldNode.item);
newNode.item = item;
newNode.next = next;
pj.update(oldNode, newNode);
}
public void push(T item) {
Node oldFirst = first;
first = new Node();
first.item = item;
first.next = oldFirst;
size++;
}
/** Add the item to the stack. */
public void push(Item item) {
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
N++;
assert check();
}
public void enqueue(Item item) {
Node oldlast = last;
Node last = new Node();
last.item = item;
if (isEmpty()) first = last;
else oldlast.next = last;
N++;
}
/**
* Replaces the element at the specified position in this {@code LinkedList} with the specified
* element. Returns the element previously at the specified index.
*
* @param index The index of the element to replace.
* @param element The element to be stored at the specified index.
* @return The element previously at the specified index.
* @throws IndexOutOfBoundsException if the specified index value is out of range.
*/
@Override
public E set(int index, E element) {
rangeCheck(index);
Node<E> n = nodeAt(index);
E oldItem = n.item;
n.item = element;
return oldItem;
}
/**
* Sets the given element to the underlying {@code LinkedList} at the current cursor index.
*
* @param element The element to set at the specified index in the backing {@code LinkedList}.
* @throws ConcurrentModificationException if the expected modification count does not equal
* that of the underlying {@code LinkedList}.
* @throws IllegalStateException if the {@link #next()} method has not previously been called or
* the {@link #remove()} method has already been called after the last call to the {@link
* #next()} method.
*/
@Override
public void set(E element) {
if (lastReturned == null) {
throw new IllegalStateException("No current index!");
}
checkForComodification();
lastReturned.item = element;
}
public void enqueue(String str) {
Node oldlast = last;
last = new Node();
last.item = str;
last.next = null;
if (isEmpty()) first = last;
else oldlast.next = last;
}
/** Add the item to the stack. */
public void push(Item item) {
Node previous = head;
head = new Node();
head.item = item;
head.previous = previous;
N++;
assert check();
}
/**
* Adds the item to this queue.
*
* @param item the item to add
*/
public void enqueue(Item item) {
Node<Item> oldlast = last;
last = new Node<Item>();
last.item = item;
last.next = null;
if (isEmpty()) first = last; // 防止oldlast==null,而访问.next报空指针异常
else oldlast.next = last;
N++;
}
/**
* Store node for reuse it later.
*
* @param node node for reuse.
*/
private void freeNode(Node<E> node) {
node.item = null;
Node<E> oldNew;
do {
oldNew = freeNode;
node.next = oldNew;
} while (!casNewNode(oldNew, node));
}
public void engueue(Item item) {
Node oldLast = last;
last = new Node();
last.item = item;
last.next = null;
count++;
if (isEmpty()) first = last;
else oldLast.next = last;
}
public void addFirst(Item item) // insert the item at the front
{
if (item == null) {
throw new java.lang.NullPointerException();
}
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
size++;
}
// add the item to the end
public void addLast(Item item) {
if (item == null) throw new java.lang.NullPointerException();
Node oldLast = last;
last = new Node();
last.item = item;
last.last = oldLast;
last.next = null;
if (oldLast != null) oldLast.next = last;
else first = last;
N++;
}
public void addLast(Item item) // insert the item at the end
{
if (item == null) {
throw new java.lang.NullPointerException();
}
Node oldLast = last;
last = new Node();
last.item = item;
last.next = null;
oldLast.next = last;
}
/** Add the item to the queue. */
public void enqueue(Item item) {
Node x = new Node();
x.item = item;
if (isEmpty()) {
first = x;
last = x;
} else {
last.next = x;
last = x;
}
N++;
}
public void append(Item item) {
Node n = new Node();
n.item = item;
n.next = null;
if (isEmpty()) {
first = n;
last = n;
} else {
last.next = n;
last = n;
}
N++;
}
public void enqueue(Item item) // add the item
{
if (item == null) {
throw new java.lang.NullPointerException("Not allowed to add null");
}
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
first.prev = null;
if (oldfirst != null) oldfirst.prev = first;
else last = first;
size++;
}
/**
* Removes all elements contained within this {@code LinkedList}. After this method call, {@link
* #isEmpty()} should always return {@code true}.
*
* <p>This operation constitutes a structural modification.
*/
@Override
public void clear() {
Node<E> next;
for (Node<E> n = first; n != null; n = next) {
next = n.nextLink;
n.item = null;
n.previousLink = null;
n.nextLink = null;
}
first = null;
last = null;
size = 0;
modCount++;
}
public void insertAtEnd(Item a) {
Node new_node = new Node();
new_node.item = a;
if (size == 0) {
first = new_node;
last = new_node;
} else {
last.next = new_node;
last = new_node;
}
size++;
}
/*
* insert the item at the end
*/
public void addLast(Item item) {
if (item == null) {
throw new java.lang.NullPointerException();
} else {
if (N == 0) { // adding to the empty deque
// full new node construction
first = new Node();
first.item = item;
// links from new node
first.prev = sPre;
first.next = sPost;
last = first;
// links to new node
sPre.next = first;
sPost.prev = first;
} else {
// StdOut.println("\naddLast() case 2");
// node before which to insert
Node oldLast = last;
// full new node construction
last = new Node();
last.item = item;
// links from new node
last.prev = oldLast;
last.next = sPost;
// links to new node
oldLast.next = last;
sPost.prev = last;
}
N++;
}
}
