ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166y/LinkedTransferQueue.java

Comparing jsr166/src/jsr166y/LinkedTransferQueue.java (file contents):
Revision 1.34 by jsr166, Thu Jul 30 17:30:26 2009 UTC vs.
Revision 1.40 by jsr166, Sat Aug 1 20:26:50 2009 UTC

#	Line 10 | Line 10 | import java.util.concurrent.*;
10
11		import java.util.AbstractQueue;
12		import java.util.Collection;
13	+	import java.util.ConcurrentModificationException;
14		import java.util.Iterator;
15		import java.util.NoSuchElementException;
16	+	import java.util.Queue;
17		import java.util.concurrent.locks.LockSupport;
18		import java.util.concurrent.atomic.AtomicReference;
19
#	Line 292 | Line 294 | public class LinkedTransferQueue<E> exte
294		* @param e the comparison value for checking match
295		* @param mode mode
296		* @param nanos timeout value
297	<	* @return matched item, or s if cancelled
297	>	* @return matched item, or null if cancelled
298		*/
299		private E awaitFulfill(Node<E> pred, Node<E> s, E e,
300		int mode, long nanos) {
#	Line 358 | Line 360 | public class LinkedTransferQueue<E> exte
360		for (;;) {
361		Node<E> h = head.get();
362		Node<E> first = h.next;
363	<	if (first != null && first.next == first) { // help advance
363	>	if (first != null && first.get() == first) { // help advance
364		advanceHead(h, first);
365		continue;
366		}
#	Line 471 | Line 473 | public class LinkedTransferQueue<E> exte
473		}
474
475		/**
476	<	* @throws InterruptedException {@inheritDoc}
477	<	* @throws NullPointerException {@inheritDoc}
476	>	* Inserts the specified element at the tail of this queue.
477	>	* As the queue is unbounded, this method will never block.
478	>	*
479	>	* @throws NullPointerException if the specified element is null
480		*/
481	<	public void put(E e) throws InterruptedException {
482	<	if (e == null) throw new NullPointerException();
479	<	if (Thread.interrupted()) throw new InterruptedException();
480	<	xfer(e, NOWAIT, 0);
481	>	public void put(E e) {
482	>	offer(e);
483		}
484
485		/**
486	<	* @throws InterruptedException {@inheritDoc}
487	<	* @throws NullPointerException {@inheritDoc}
486	>	* Inserts the specified element at the tail of this queue.
487	>	* As the queue is unbounded, this method will never block or
488	>	* return {@code false}.
489	>	*
490	>	* @return {@code true} (as specified by
491	>	*  {@link BlockingQueue#offer(Object,long,TimeUnit) BlockingQueue.offer})
492	>	* @throws NullPointerException if the specified element is null
493		*/
494	<	public boolean offer(E e, long timeout, TimeUnit unit)
495	<	throws InterruptedException {
489	<	if (e == null) throw new NullPointerException();
490	<	if (Thread.interrupted()) throw new InterruptedException();
491	<	xfer(e, NOWAIT, 0);
492	<	return true;
494	>	public boolean offer(E e, long timeout, TimeUnit unit) {
495	>	return offer(e);
496		}
497
498		/**
499	<	* @throws NullPointerException {@inheritDoc}
499	>	* Inserts the specified element at the tail of this queue.
500	>	* As the queue is unbounded, this method will never return {@code false}.
501	>	*
502	>	* @return {@code true} (as specified by
503	>	*         {@link BlockingQueue#offer(Object) BlockingQueue.offer})
504	>	* @throws NullPointerException if the specified element is null
505		*/
506		public boolean offer(E e) {
507		if (e == null) throw new NullPointerException();
#	Line 502 | Line 510 | public class LinkedTransferQueue<E> exte
510		}
511
512		/**
513	<	* @throws NullPointerException {@inheritDoc}
513	>	* Inserts the specified element at the tail of this queue.
514	>	* As the queue is unbounded, this method will never throw
515	>	* {@link IllegalStateException} or return {@code false}.
516	>	*
517	>	* @return {@code true} (as specified by {@link Collection#add})
518	>	* @throws NullPointerException if the specified element is null
519		*/
520		public boolean add(E e) {
521	+	return offer(e);
522	+	}
523	+
524	+	/**
525	+	* Transfers the element to a waiting consumer immediately, if possible.
526	+	*
527	+	* <p>More precisely, transfers the specified element immediately
528	+	* if there exists a consumer already waiting to receive it (in
529	+	* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
530	+	* otherwise returning {@code false} without enqueuing the element.
531	+	*
532	+	* @throws NullPointerException if the specified element is null
533	+	*/
534	+	public boolean tryTransfer(E e) {
535		if (e == null) throw new NullPointerException();
536	<	xfer(e, NOWAIT, 0);
510	<	return true;
536	>	return fulfill(e) != null;
537		}
538
539		/**
540	<	* @throws InterruptedException {@inheritDoc}
541	<	* @throws NullPointerException {@inheritDoc}
540	>	* Transfers the element to a consumer, waiting if necessary to do so.
541	>	*
542	>	* <p>More precisely, transfers the specified element immediately
543	>	* if there exists a consumer already waiting to receive it (in
544	>	* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
545	>	* else inserts the specified element at the tail of this queue
546	>	* and waits until the element is received by a consumer.
547	>	*
548	>	* @throws NullPointerException if the specified element is null
549		*/
550		public void transfer(E e) throws InterruptedException {
551		if (e == null) throw new NullPointerException();
#	Line 523 | Line 556 | public class LinkedTransferQueue<E> exte
556		}
557
558		/**
559	<	* @throws InterruptedException {@inheritDoc}
560	<	* @throws NullPointerException {@inheritDoc}
559	>	* Transfers the element to a consumer if it is possible to do so
560	>	* before the timeout elapses.
561	>	*
562	>	* <p>More precisely, transfers the specified element immediately
563	>	* if there exists a consumer already waiting to receive it (in
564	>	* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
565	>	* else inserts the specified element at the tail of this queue
566	>	* and waits until the element is received by a consumer,
567	>	* returning {@code false} if the specified wait time elapses
568	>	* before the element can be transferred.
569	>	*
570	>	* @throws NullPointerException if the specified element is null
571		*/
572		public boolean tryTransfer(E e, long timeout, TimeUnit unit)
573		throws InterruptedException {
#	Line 536 | Line 579 | public class LinkedTransferQueue<E> exte
579		throw new InterruptedException();
580		}
581
539	–	/**
540	–	* @throws NullPointerException {@inheritDoc}
541	–	*/
542	–	public boolean tryTransfer(E e) {
543	–	if (e == null) throw new NullPointerException();
544	–	return fulfill(e) != null;
545	–	}
546	–
547	–	/**
548	–	* @throws InterruptedException {@inheritDoc}
549	–	*/
582		public E take() throws InterruptedException {
583		E e = xfer(null, WAIT, 0);
584		if (e != null)
#	Line 555 | Line 587 | public class LinkedTransferQueue<E> exte
587		throw new InterruptedException();
588		}
589
558	–	/**
559	–	* @throws InterruptedException {@inheritDoc}
560	–	*/
590		public E poll(long timeout, TimeUnit unit) throws InterruptedException {
591		E e = xfer(null, TIMEOUT, unit.toNanos(timeout));
592		if (e != null || !Thread.interrupted())
#	Line 635 | Line 664 | public class LinkedTransferQueue<E> exte
664		}
665		}
666
667	+	/**
668	+	* Returns an iterator over the elements in this queue in proper
669	+	* sequence, from head to tail.
670	+	*
671	+	* <p>The returned iterator is a "weakly consistent" iterator that
672	+	* will never throw
673	+	* {@link ConcurrentModificationException ConcurrentModificationException},
674	+	* and guarantees to traverse elements as they existed upon
675	+	* construction of the iterator, and may (but is not guaranteed
676	+	* to) reflect any modifications subsequent to construction.
677	+	*
678	+	* @return an iterator over the elements in this queue in proper sequence
679	+	*/
680		public Iterator<E> iterator() {
681		return new Itr();
682		}
#	Line 689 | Line 731 | public class LinkedTransferQueue<E> exte
731		}
732
733		public E next() {
734	<	if (next == null)
734	>	if (next == null)
735		throw new NoSuchElementException();
736		return advance();
737		}
#	Line 823 | Line 865 | public class LinkedTransferQueue<E> exte
865		}
866		}
867
868	+	/**
869	+	* Always returns {@code Integer.MAX_VALUE} because a
870	+	* {@code LinkedTransferQueue} is not capacity constrained.
871	+	*
872	+	* @return {@code Integer.MAX_VALUE} (as specified by
873	+	*         {@link BlockingQueue#remainingCapacity()})
874	+	*/
875		public int remainingCapacity() {
876		return Integer.MAX_VALUE;
877		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines