import java.util.concurrent.Callable;

/**
 * Utility class that provides a lazy initialization object wrapper.
 * <p/>
 * To use this wrapper simply implement {@link java.util.concurrent.Callable#call()} and return the appropriate value.
 * Exceptions are propagated by {@link #get()} as {@link com.tomergabel.util.LazyInitializationException}s.
 * <p/>
 * <strong>Note: This wrapper is <em>not</em> thread-safe!</strong>
 *
 * @param <T> The type wrapped by the lazy initializer.
 */
public abstract class Lazy<T> implements Callable<T> {
    /**
     * The actual value.
     */
    private T value = null;

    /**
     * Protected c'tor (to prevent direct initialization.
     */
    protected Lazy() {
    }

    /**
     * A private c'tor used to pre-cache the value. This is used by the convenience method {@link #from(Object)} to
     * create a "const" lazy initializer.
     *
     * @param value The actual value.
     */
    private Lazy( final T value ) {
        this.value = value;
    }

    /**
     * Retreives the lazy-loaded value, initializing it on the fly if necessary.
     *
     * @return The lazy-loaded value.
     * @throws LazyInitializationException An error has occurred while initializing the lazy-loaded value. Please see
     *                                     the exception {@link Exception#getCause() cause} for detials.
     */
    public T get() throws LazyInitializationException {
        try {
            return this.value == null ? ( this.value = this.call() ) : this.value;
        } catch ( Exception e ) {
            throw new LazyInitializationException( e );
        }
    }

    /**
     * Wraps a value with a pre-cached value. This is a convenience method intended to provide an easy way to specify
     * constant values to a lazy-loaded placeholder if necessary.
     *
     * @param value The actual value.
     * @param <T>   The type wrapped by the lazy initializer.
     * @return A {@link Lazy} instance for the specified value.
     */
    public static <T> Lazy<T> from( final T value ) {
        return new Lazy<T>( value ) {
            @Override
            public T call() throws Exception {
                // Safety net, should never happen
                throw new IllegalStateException( "Lazy initializer should be not called on lazy constants." );
            }
        };
    }

    /**
     * Wraps the specified callable with a {@link Lazy} instance. This is an alternative to extending this class.
     *
     * @param initializer The initializer. Calling {@link #from} with {@literal null} for an argument will resolve here,
     *                    so specifying a {@literal null} initializer is the same as specifying a callable which returns
     *                    {@literal null}.
     * @return A {@link Lazy} instance for the specified initializer.
     */
    @SuppressWarnings( { "unchecked" } )
    public static <T> Lazy<T> from( final Callable<T> initializer ) {
        return new Lazy<T>() {
            @Override
            public T call() throws Exception {
                // Lazy.from( null ) will resolve here, so (as a convenience) we support
                // return of null values
                return initializer == null ? null : initializer.call();
            }
        };
    }
}
class LazyInitializationException extends Exception {
    public LazyInitializationException( final String message, final Throwable cause ) {
        super( message, cause );
    }

    public LazyInitializationException( final Throwable cause ) {
        super( cause );
    }
}

public class LazyLoadingReference<T> {

  protected Factory<T> factory;

  protected AtomicReference<WeakReference<Future<T>>> reference = new AtomicReference<WeakReference<Future<T>>>();

  public LazyLoadingReference(Factory<T> factory) {
    this.factory = factory;
  }

  public T get() throws IllegalStateException {
    while (true) {
      WeakReference<Future<T>> ref = reference.get();
      boolean valid = true;
      if (ref == null) {
        FutureTask<T> f = new FutureTask<T>(new Callable<T>() {
          @Override
          public T call() throws Exception {
            return factory.create();
          }
        });
        ref = new WeakReference<Future<T>>(f);
        if (valid = reference.compareAndSet(null, ref)) {
          f.run();
        }
      }
      if (valid) {
        try {
          Future<T> f = ref.get();
          if (f != null) {
            return f.get();
          } else {
            reference.compareAndSet(ref, null);
          }
        } catch (CancellationException e) {
          reference.compareAndSet(ref, null);
        } catch (ExecutionException e) {
          throw new IllegalStateException(e.getCause());
        } catch (Exception e) {
          throw new IllegalStateException(e);
        }
      }
    }
  }

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CancellationException;

import org.t2framework.commons.cache.Cache;
import org.t2framework.commons.cache.CacheFactory;
import org.t2framework.commons.cache.CacheType;

import junit.framework.TestCase;

public class LazyLoadingReferenceTest extends TestCase {

  public void test_loadSimple() throws Exception {
    LazyLoadingReference<String> target = new LazyLoadingReference<String>(
        new LazyLoadingReference.Factory<String>() {
          public String create() {
            return "hoge";
          }
        });
    assertEquals("hoge", target.get());
  }

  public void test_loadSimple2() throws Exception {
    LazyLoadingReference<Cache<String, String>> t2 = new LazyLoadingReference<Cache<String, String>>(
        new LazyLoadingReference.Factory<Cache<String, String>>() {

          @Override
          public Cache<String, String> create()
              throws CancellationException {
            Cache<String, String> c = CacheFactory
                .createCache(CacheType.DEFAULT);
            c.put("aaa", "bbb");
            return c;
          }
        });
    Cache<String, String> cache = t2.get();
    assertNotNull(cache);
    assertNotNull(cache.get("aaa"));

  }

  public void test_exception() throws Exception {
    final Exception e = new Exception();
    LazyLoadingReference<String> target = new LazyLoadingReference<String>(
        new LazyLoadingReference.Factory<String>() {
          public String create() throws Exception {
            throw e;
          }
        });
    try {
      target.get();
      fail();
    } catch (IllegalStateException t) {
      assertNotNull(t.getCause());
      assertTrue(t.getCause().getClass() == Exception.class);
      assertEquals(e, t.getCause());
    }
  }

import java.util.ArrayDeque;
import java.util.Queue;

import java.util.concurrent.BlockingQueue;

/**
 * A daemon thread that continuously dequeues {@code Runnable} instances from a
 * queue and executes them.  This class is intended to be used with a {@link
 * java.util.concurrent.Semaphore Semaphore}, whereby work is added the to the
 * queue and the semaphore indicates when processing has finished.
 *
 * @author David Jurgens
 */
public class WorkerThread extends Thread {

    /**
     * A static variable to indicate which instance of the class the current
     * thread is in its name.
     */
    private static int threadInstanceCount;

    /**
     * The queue from which work items will be taken
     */
    private final BlockingQueue<Runnable> workQueue;

    /**
     * An internal queue that holds thread-local tasks.  This queue is intended
     * to hold multiple tasks to avoid thread contention on the work queue.
     */
    private final Queue<Runnable> internalQueue;

    /**
     * The number of items that should be queued to run by this thread at once.
     */
    private final int threadLocalItems;

    /**
     * Creates a thread that continuously dequeues from the {@code workQueue} at
     * once and excutes each item.
     */
    public WorkerThread(BlockingQueue<Runnable> workQueue) {
        this(workQueue, 1);
    }

    /**
     * Creates a thread that continuously dequeues {@code threadLocalItems} from
     * {@code workQueue} at once and excutes them sequentially.
     *
     * @param threadLocalItems the number of items this thread should dequeue
     *        from the work queue at one time.  Setting this value too high can
     *        result in a loss of concurrency; setting it too low can result in
     *        high contention on the work queue if the time per task is also
     *        low.
     */
    public WorkerThread(BlockingQueue<Runnable> workQueue, 
                        int threadLocalItems) {
        this.workQueue = workQueue;
        this.threadLocalItems = threadLocalItems;
        internalQueue = new ArrayDeque<Runnable>();
        setDaemon(true);
        synchronized(WorkerThread.class) {
            setName("WorkerThread-" + (threadInstanceCount++));
        }
    }

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;

/**
 * A static container class for URI-related utility functions.
 */
public final class UriUtils {
      /**
     * A static URI which, when resolved against another URI, returns the other URI's parent.
     */
    private static final URI up = URI.create( ".." );

    /**
     * Returns the parent of the specified URI.
     * <p/>
     * For example, applying this method to the URI &quot;<tt>http://www.site.com/articles/article.html</tt>&quot; will
     * return the URI for &quot;<tt>http://www.site.com/articles/</tt>&quot;.
     *
     * @param uri The URI for which to return the parent.
     * @return The parent of the specified URI.
     * @throws IllegalArgumentException <ul> <li>The URI cannot be null></li> <li>Can't resolve parent for the specified
     *                                  URI.</li> </ul>
     */
    public static URI getParent( final URI uri ) throws IllegalArgumentException {
        if ( uri == null )
            throw new IllegalArgumentException( "The URI cannot be null." );

        final String path = uri.toString();
        final int finalSeparator = Math.max( path.lastIndexOf( '/' ), path.lastIndexOf( '\\' ) );
        final int extension = path.lastIndexOf( '.' );
        if ( extension > finalSeparator )
            try {
                // Extract all but final segment
                return new URI( path.substring( 0, finalSeparator + 1 ) ).normalize();
            } catch ( URISyntaxException e ) {
                throw new IllegalArgumentException( "Can't resolve parent for the specified URI.", e );
            }
        else
            return uri.resolve( up );
    }
}

  /**
   * Throws NullPointerException if argument is null
   * 
   * @param v
   *            the element
   */
  private static void checkNullArg(Object v) {
    if (v == null)
      throw new NullPointerException();
  }

  /**
   * Returns element unless it is null, in which case throws
   * NoSuchElementException.
   * 
   * @param v
   *            the element
   * @return the element
   */
  private E screenNullResult(E v) {
    if (v == null)
      throw new NoSuchElementException();
    return v;
  }

  /**
   * Creates an array list and fills it with elements of this list. Used by
   * toArray.
   * 
   * @return the arrayList
   */
  private ArrayList<E> toArrayList() {
    ArrayList<E> c = new ArrayList<E>();
    for (Node<E> n = header.forward(); n != null; n = n.forward())
      c.add(n.element);
    return c;
  }

  // Fields and constructors

  private static final long serialVersionUID = 876323262645176354L;

  /**
   * List header. First usable node is at header.forward().
   */
  private final Node<E> header;

  /**
   * List trailer. Last usable node is at trailer.back().
   */
  private final Node<E> trailer;

  /**
   * Constructs an empty deque.
   */
  public ConcurrentDoublyLinkedList() {
    Node h = new Node(null, null, null);
    Node t = new Node(null, null, h);
    h.setNext(t);
    header = h;
    trailer = t;
  }

  /**
   * Constructs a deque containing the elements of the specified collection,
   * in the order they are returned by the collection's iterator.
   * 
   * @param c
   *            the collection whose elements are to be placed into this
   *            deque.
   * @throws NullPointerException
   *             if <tt>c</tt> or any element within it is <tt>null</tt>
   */
  public ConcurrentDoublyLinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
  }

  /**
   * Prepends the given element at the beginning of this deque.
   * 
   * @param o
   *            the element to be inserted at the beginning of this deque.
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public void addFirst(E o) {
    checkNullArg(o);
    while (header.append(o) == null)
      ;
  }

  /**
   * Appends the given element to the end of this deque. This is identical in
   * function to the <tt>add</tt> method.
   * 
   * @param o
   *            the element to be inserted at the end of this deque.
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public void addLast(E o) {
    checkNullArg(o);
    while (trailer.prepend(o) == null)
      ;
  }

  /**
   * Prepends the given element at the beginning of this deque.
   * 
   * @param o
   *            the element to be inserted at the beginning of this deque.
   * @return <tt>true</tt> always
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public boolean offerFirst(E o) {
    addFirst(o);
    return true;
  }

  /**
   * Appends the given element to the end of this deque. (Identical in
   * function to the <tt>add</tt> method; included only for consistency.)
   * 
   * @param o
   *            the element to be inserted at the end of this deque.
   * @return <tt>true</tt> always
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public boolean offerLast(E o) {
    addLast(o);
    return true;
  }

  /**
   * Retrieves, but does not remove, the first element of this deque, or
   * returns null if this deque is empty.
   * 
   * @return the first element of this queue, or <tt>null</tt> if empty.
   */
  public E peekFirst() {
    Node<E> n = header.successor();
    return (n == null) ? null : n.element;
  }

  /**
   * Retrieves, but does not remove, the last element of this deque, or
   * returns null if this deque is empty.
   * 
   * @return the last element of this deque, or <tt>null</tt> if empty.
   */
  public E peekLast() {
    Node<E> n = trailer.predecessor();
    return (n == null) ? null : n.element;
  }

  /**
   * Returns the first element in this deque.
   * 
   * @return the first element in this deque.
   * @throws NoSuchElementException
   *             if this deque is empty.
   */
  public E getFirst() {
    return screenNullResult(peekFirst());
  }

  /**
   * Returns the last element in this deque.
   * 
   * @return the last element in this deque.
   * @throws NoSuchElementException
   *             if this deque is empty.
   */
  public E getLast() {
    return screenNullResult(peekLast());
  }

  /**
   * Retrieves and removes the first element of this deque, or returns null if
   * this deque is empty.
   * 
   * @return the first element of this deque, or <tt>null</tt> if empty.
   */
  public E pollFirst() {
    for (;;) {
      Node<E> n = header.successor();
      if (!usable(n))
        return null;
      if (n.delete())
        return n.element;
    }
  }

  /**
   * Retrieves and removes the last element of this deque, or returns null if
   * this deque is empty.
   * 
   * @return the last element of this deque, or <tt>null</tt> if empty.
   */
  public E pollLast() {
    for (;;) {
      Node<E> n = trailer.predecessor();
      if (!usable(n))
        return null;
      if (n.delete())
        return n.element;
    }
  }

  /**
   * Removes and returns the first element from this deque.
   * 
   * @return the first element from this deque.
   * @throws NoSuchElementException
   *             if this deque is empty.
   */
  public E removeFirst() {
    return screenNullResult(pollFirst());
  }

  /**
   * Removes and returns the last element from this deque.
   * 
   * @return the last element from this deque.
   * @throws NoSuchElementException
   *             if this deque is empty.
   */
  public E removeLast() {
    return screenNullResult(pollLast());
  }

  // *** Queue and stack methods ***
  public boolean offer(E e) {
    return offerLast(e);
  }

  public boolean add(E e) {
    return offerLast(e);
  }

  public E poll() {
    return pollFirst();
  }

  public E remove() {
    return removeFirst();
  }

  public E peek() {
    return peekFirst();
  }

  public E element() {
    return getFirst();
  }

  public void push(E e) {
    addFirst(e);
  }

  public E pop() {
    return removeFirst();
  }

  /**
   * Removes the first element <tt>e</tt> such that <tt>o.equals(e)</tt>,
   * if such an element exists in this deque. If the deque does not contain
   * the element, it is unchanged.
   * 
   * @param o
   *            element to be removed from this deque, if present.
   * @return <tt>true</tt> if the deque contained the specified element.
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public boolean removeFirstOccurrence(Object o) {
    checkNullArg(o);
    for (;;) {
      Node<E> n = header.forward();
      for (;;) {
        if (n == null)
          return false;
        if (o.equals(n.element)) {
          if (n.delete())
            return true;
          else
            break; // restart if interference
        }
        n = n.forward();
      }
    }
  }

  /**
   * Removes the last element <tt>e</tt> such that <tt>o.equals(e)</tt>,
   * if such an element exists in this deque. If the deque does not contain
   * the element, it is unchanged.
   * 
   * @param o
   *            element to be removed from this deque, if present.
   * @return <tt>true</tt> if the deque contained the specified element.
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public boolean removeLastOccurrence(Object o) {
    checkNullArg(o);
    for (;;) {
      Node<E> s = trailer;
      for (;;) {
        Node<E> n = s.back();
        if (s.isDeleted() || (n != null && n.successor() != s))
          break; // restart if pred link is suspect.
        if (n == null)
          return false;
        if (o.equals(n.element)) {
          if (n.delete())
            return true;
          else
            break; // restart if interference
        }
        s = n;
      }
    }
  }

  /**
   * Returns <tt>true</tt> if this deque contains at least one element
   * <tt>e</tt> such that <tt>o.equals(e)</tt>.
   * 
   * @param o
   *            element whose presence in this deque is to be tested.
   * @return <tt>true</tt> if this deque contains the specified element.
   */
  public boolean contains(Object o) {
    if (o == null)
      return false;
    for (Node<E> n = header.forward(); n != null; n = n.forward())
      if (o.equals(n.element))
        return true;
    return false;
  }

  /**
   * Returns <tt>true</tt> if this collection contains no elements.
   * <p>
   * 
   * @return <tt>true</tt> if this collection contains no elements.
   */
  public boolean isEmpty() {
    return !usable(header.successor());
  }

  /**
   * Returns the number of elements in this deque. If this deque contains more
   * than <tt>Integer.MAX_VALUE</tt> elements, it returns
   * <tt>Integer.MAX_VALUE</tt>.
   * 
   * <p>
   * Beware that, unlike in most collections, this method is <em>NOT</em> a
   * constant-time operation. Because of the asynchronous nature of these
   * deques, determining the current number of elements requires traversing
   * them all to count them. Additionally, it is possible for the size to
   * change during execution of this method, in which case the returned result
   * will be inaccurate. Thus, this method is typically not very useful in
   * concurrent applications.
   * 
   * @return the number of elements in this deque.
   */
  public int size() {
    long count = 0;
    for (Node<E> n = header.forward(); n != null; n = n.forward())
      ++count;
    return (count >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) count;
  }

  /**
   * Removes the first element <tt>e</tt> such that <tt>o.equals(e)</tt>,
   * if such an element exists in this deque. If the deque does not contain
   * the element, it is unchanged.
   * 
   * @param o
   *            element to be removed from this deque, if present.
   * @return <tt>true</tt> if the deque contained the specified element.
   * @throws NullPointerException
   *             if the specified element is <tt>null</tt>
   */
  public boolean remove(Object o) {
    return removeFirstOccurrence(o);
  }

  /**
   * Appends all of the elements in the specified collection to the end of
   * this deque, in the order that they are returned by the specified
   * collection's iterator. The behavior of this operation is undefined if the
   * specified collection is modified while the operation is in progress.
   * (This implies that the behavior of this call is undefined if the
   * specified Collection is this deque, and this deque is nonempty.)
   * 
   * @param c
   *            the elements to be inserted into this deque.
   * @return <tt>true</tt> if this deque changed as a result of the call.
   * @throws NullPointerException
   *             if <tt>c</tt> or any element within it is <tt>null</tt>
   */
  public boolean addAll(Collection<? extends E> c) {
    Iterator<? extends E> it = c.iterator();
    if (!it.hasNext())
      return false;
    do {
      addLast(it.next());
    } while (it.hasNext());
    return true;
  }

  /**
   * Removes all of the elements from this deque.
   */
  public void clear() {
    while (pollFirst() != null)
      ;
  }

  /**
   * Returns an array containing all of the elements in this deque in the
   * correct order.
   * 
   * @return an array containing all of the elements in this deque in the
   *         correct order.
   */
  public Object[] toArray() {
    return toArrayList().toArray();
  }

  /**
   * Returns an array containing all of the elements in this deque in the
   * correct order; the runtime type of the returned array is that of the
   * specified array. If the deque fits in the specified array, it is returned
   * therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of this deque.
   * <p>
   * 
   * If the deque fits in the specified array with room to spare (i.e., the
   * array has more elements than the deque), the element in the array
   * immediately following the end of the collection is set to null. This is
   * useful in determining the length of the deque <i>only</i> if the caller
   * knows that the deque does not contain any null elements.
   * 
   * @param a
   *            the array into which the elements of the deque are to be
   *            stored, if it is big enough; otherwise, a new array of the
   *            same runtime type is allocated for this purpose.
   * @return an array containing the elements of the deque.
   * @throws ArrayStoreException
   *             if the runtime type of a is not a supertype of the runtime
   *             type of every element in this deque.
   * @throws NullPointerException
   *             if the specified array is null.
   */
  public <T> T[] toArray(T[] a) {
    return toArrayList().toArray(a);
  }

  /**
   * Returns a weakly consistent iterator over the elements in this deque, in
   * first-to-last order. The <tt>next</tt> method returns elements
   * reflecting the state of the deque at some point at or since the creation
   * of the iterator. The method does <em>not</em> throw
   * {@link ConcurrentModificationException}, and may proceed concurrently
   * with other operations.
   * 
   * @return an iterator over the elements in this deque
   */
  public Iterator<E> iterator() {
    return new CLDIterator();
  }

  final class CLDIterator implements Iterator<E> {
    Node<E> last;

    Node<E> next = header.forward();

    public boolean hasNext() {
      return next != null;
    }

    public E next() {
      Node<E> l = last = next;
      if (l == null)
        throw new NoSuchElementException();
      next = next.forward();
      return l.element;
    }

    public void remove() {
      Node<E> l = last;
      if (l == null)
        throw new IllegalStateException();
      while (!l.delete() && !l.isDeleted())
        ;
    }
  }

}

/**
 * Linked Nodes. As a minor efficiency hack, this class opportunistically
 * inherits from AtomicReference, with the atomic ref used as the "next"
 * link.
 * 
 * Nodes are in doubly-linked lists. There are three kinds of special nodes,
 * distinguished by: * The list header has a null prev link * The list
 * trailer has a null next link * A deletion marker has a prev link pointing
 * to itself. All three kinds of special nodes have null element fields.
 * 
 * Regular nodes have non-null element, next, and prev fields. To avoid
 * visible inconsistencies when deletions overlap element replacement,
 * replacements are done by replacing the node, not just setting the
 * element.
 * 
 * Nodes can be traversed by read-only ConcurrentLinkedDeque class
 * operations just by following raw next pointers, so long as they ignore
 * any special nodes seen along the way. (This is automated in method
 * forward.) However, traversal using prev pointers is not guaranteed to see
 * all live nodes since a prev pointer of a deleted node can become
 * unrecoverably stale.
 */

 class Node<E> extends AtomicReference<Node<E>> {
  private volatile Node<E> prev;

  final E element;

  /** Creates a node with given contents */
  Node(E element, Node<E> next, Node<E> prev) {
    super(next);
    this.prev = prev;
    this.element = element;
  }

  /** Creates a marker node with given successor */
  Node(Node<E> next) {
    super(next);
    this.prev = this;
    this.element = null;
  }

  /**
   * Gets next link (which is actually the value held as atomic
   * reference).
   */
  private Node<E> getNext() {
    return get();
  }

  /**
   * Sets next link
   * 
   * @param n
   *            the next node
   */
  void setNext(Node<E> n) {
    set(n);
  }

  /**
   * compareAndSet next link
   */
  private boolean casNext(Node<E> cmp, Node<E> val) {
    return compareAndSet(cmp, val);
  }

  /**
   * Gets prev link
   */
  private Node<E> getPrev() {
    return prev;
  }

  /**
   * Sets prev link
   * 
   * @param b
   *            the previous node
   */
  void setPrev(Node<E> b) {
    prev = b;
  }

  /**
   * Returns true if this is a header, trailer, or marker node
   */
  boolean isSpecial() {
    return element == null;
  }

  /**
   * Returns true if this is a trailer node
   */
  boolean isTrailer() {
    return getNext() == null;
  }

  /**
   * Returns true if this is a header node
   */
  boolean isHeader() {
    return getPrev() == null;
  }

  /**
   * Returns true if this is a marker node
   */
  boolean isMarker() {
    return getPrev() == this;
  }

  /**
   * Returns true if this node is followed by a marker, meaning that it is
   * deleted.
   * 
   * @return true if this node is deleted
   */
  boolean isDeleted() {
    Node<E> f = getNext();
    return f != null && f.isMarker();
  }

  /**
   * Returns next node, ignoring deletion marker
   */
  private Node<E> nextNonmarker() {
    Node<E> f = getNext();
    return (f == null || !f.isMarker()) ? f : f.getNext();
  }

  /**
   * Returns the next non-deleted node, swinging next pointer around any
   * encountered deleted nodes, and also patching up successor''s prev
   * link to point back to this. Returns null if this node is trailer so
   * has no successor.
   * 
   * @return successor, or null if no such
   */
  Node<E> successor() {
    Node<E> f = nextNonmarker();
    for (;;) {
      if (f == null)
        return null;
      if (!f.isDeleted()) {
        if (f.getPrev() != this && !isDeleted())
          f.setPrev(this); // relink f's prev
        return f;
      }
      Node<E> s = f.nextNonmarker();
      if (f == getNext())
        casNext(f, s); // unlink f
      f = s;
    }
  }

  /**
   * Returns the apparent predecessor of target by searching forward for
   * it starting at this node, patching up pointers while traversing. Used
   * by predecessor().
   * 
   * @return target's predecessor, or null if not found
   */
  private Node<E> findPredecessorOf(Node<E> target) {
    Node<E> n = this;
    for (;;) {
      Node<E> f = n.successor();
      if (f == target)
        return n;
      if (f == null)
        return null;
      n = f;
    }
  }

  /**
   * Returns the previous non-deleted node, patching up pointers as
   * needed. Returns null if this node is header so has no successor. May
   * also return null if this node is deleted, so doesn't have a distinct
   * predecessor.
   * 
   * @return predecessor or null if not found
   */
  Node<E> predecessor() {
    Node<E> n = this;
    for (;;) {
      Node<E> b = n.getPrev();
      if (b == null)
        return n.findPredecessorOf(this);
      Node<E> s = b.getNext();
      if (s == this)
        return b;
      if (s == null || !s.isMarker()) {
        Node<E> p = b.findPredecessorOf(this);
        if (p != null)
          return p;
      }
      n = b;
    }
  }

  /**
   * Returns the next node containing a nondeleted user element. Use for
   * forward list traversal.
   * 
   * @return successor, or null if no such
   */
  Node<E> forward() {
    Node<E> f = successor();
    return (f == null || f.isSpecial()) ? null : f;
  }

  /**
   * Returns previous node containing a nondeleted user element, if
   * possible. Use for backward list traversal, but beware that if this
   * method is called from a deleted node, it might not be able to
   * determine a usable predecessor.
   * 
   * @return predecessor, or null if no such could be found
   */
  Node<E> back() {
    Node<E> f = predecessor();
    return (f == null || f.isSpecial()) ? null : f;
  }

  /**
   * Tries to insert a node holding element as successor, failing if this
   * node is deleted.
   * 
   * @param element
   *            the element
   * @return the new node, or null on failure.
   */
  Node<E> append(E element) {
    for (;;) {
      Node<E> f = getNext();
      if (f == null || f.isMarker())
        return null;
      Node<E> x = new Node<E>(element, f, this);
      if (casNext(f, x)) {
        f.setPrev(x); // optimistically link
        return x;
      }
    }
  }

  /**
   * Tries to insert a node holding element as predecessor, failing if no
   * live predecessor can be found to link to.
   * 
   * @param element
   *            the element
   * @return the new node, or null on failure.
   */
  Node<E> prepend(E element) {
    for (;;) {
      Node<E> b = predecessor();
      if (b == null)
        return null;
      Node<E> x = new Node<E>(element, this, b);
      if (b.casNext(this, x)) {
        setPrev(x); // optimistically link
        return x;
      }
    }
  }

  /**
   * Tries to mark this node as deleted, failing if already deleted or if
   * this node is header or trailer
   * 
   * @return true if successful
   */
  boolean delete() {
    Node<E> b = getPrev();
    Node<E> f = getNext();
    if (b != null && f != null && !f.isMarker()
        && casNext(f, new Node(f))) {
      if (b.casNext(this, f))
        f.setPrev(b);
      return true;
    }
    return false;
  }

   // Constructors /////////////////////////////////////////////////////////////
   
   /**
    * Constructor for Synchronized Queue Object.
    */
   public SynchronizedQueue(
   )
   {
      super();

      m_lstObjects = new LinkedList();
   }

   // Logic ////////////////////////////////////////////////////////////////////
   
   /**
    * Destructor for Synchronized Queue. It is called when no other
    * object holds reference to it.
    *
    * @exception Throwable - default destructor exception
    */
   protected void finalize(
   ) throws Throwable
   {
      // Explicitely remove this just to help garbage collector
      m_lstObjects.clear();
      m_lstObjects = null;

      super.finalize();
   }

   /**
    * Get the object from the beginning of the queue
    *
    * @return Object - object from the queue, if the thread is blocked in this
    *                  function and you call interrupt method, an InterruptedException
    *                  will be thrown.
    * @exception InterruptedException - if the thread is blocked in this
    *                                   function and you call interrupt method,
    *                                   an InterruptedException will be thrown.
    */
   public synchronized Object get(
   ) throws InterruptedException
   {
      Object objReturn = null;

      if (m_lstObjects.isEmpty())
      {
         // There is no object in the queue, go to sleep
         try
         {
            wait();
         }
         catch (InterruptedException ieException)
         {
            // Somebody woke us up, that means all threads waiting on this
            // object competed for the lock and this one won and the object is
            // locked again
            // The thread can be woken up in two conditions, producer put new
            // object into the queue or somebody called interrupt - to interrupt
            // the wait - in this case rethrow an exception
            if (m_lstObjects.isEmpty())
            {
               throw ieException;
            }
         }
      }

      // Remove the first object in the queue
      objReturn = m_lstObjects.remove(0);

      return objReturn;
   }

   /**
    * Put the object to the end of the queue.
    *
    * @param objNew - new object, can be null
    */
   public synchronized void put(
      Object objNew
   )
   {
      m_lstObjects.add(objNew);
      // New object in the queue, notify others
      notifyAll();
   }

   /**
    * Test if the queue is empty.
    *
    * @return boolean - true if the queue is empty
    */
   public synchronized boolean isEmpty(
   )
   {
      return m_lstObjects.isEmpty();
   }
}

  /**
   * Lock used only for its memory effects.
   */
  protected final BarrierLock barrierLock = new BarrierLock();

  /**
   * field written to only to guarantee lock ordering.
   */
  protected transient Object lastWrite;

  /**
   * Force a memory synchronization that will cause all readers to see table.
   * Call only when already holding main synch lock.
   * @param x 
   */
  protected final void recordModification(Object x)
  {
    synchronized (barrierLock)
    {
      lastWrite = x;
    }
  }

  /**
   * Get ref to table; the reference and the cells it accesses will be at
   * least as fresh as from last use of barrierLock
   * @return table cells
   */
  protected final Entry[] getTableForReading()
  {
    synchronized (barrierLock)
    {
      return table;
    }
  }

  /**
   * The default initial number of table slots for this table (32). Used when
   * not otherwise specified in constructor.
   */
  public static final int DEFAULT_INITIAL_CAPACITY = 32;

  /**
   * The minimum capacity, used if a lower value is implicitly specified by
   * either of the constructors with arguments. MUST be a power of two.
   */
  private static final int MINIMUM_CAPACITY = 4;

  /**
   * The maximum capacity, used if a higher value is implicitly specified by
   * either of the constructors with arguments. MUST be a power of two <= 1<<30.
   */
  private static final int MAXIMUM_CAPACITY = 1 << 30;

  /**
   * The default load factor for this table (1.0). Used when not otherwise
   * specified in constructor.
   */
  public static final float DEFAULT_LOAD_FACTOR = 0.75f;

  /**
   * The hash table data.
   */
  protected transient Entry[] table;

  /**
   * The total number of mappings in the hash table.
   */
  protected transient int count;

  /**
   * The table is rehashed when its size exceeds this threshold. (The value of
   * this field is always (int)(capacity * loadFactor).)
   * 
   * @serial
   */
  protected int threshold;

  /**
   * The load factor for the hash table.
   * 
   * @serial
   */
  protected float loadFactor;

  /**
   * Returns the appropriate capacity (power of two) for the specified initial
   * capacity argument.
   * @param initialCapacity
   * @return appropriate capacity
   */
  private int p2capacity(int initialCapacity)
  {
    int cap = initialCapacity;

    // Compute the appropriate capacity
    int result;
    if (cap > MAXIMUM_CAPACITY || cap < 0)
    {
      result = MAXIMUM_CAPACITY;
    }
    else
    {
      result = MINIMUM_CAPACITY;
      while (result < cap)
      {
        result <<= 1;
      }
    }
    return result;
  }

  /**
   * Return hash code for Object x. Since we are using power-of-two tables, it
   * is worth the effort to improve hashcode via the same multiplicative
   * scheme as used in IdentityHashMap.
   * @param x 
   * @return hash code
   */
  private static int hash(Object x)
  {
    int h = x.hashCode();
    // Multiply by 127 (quickly, via shifts), and mix in some high
    // bits to help guard against bunching of codes that are
    // consecutive or equally spaced.
    return ((h << 7) - h + (h >>> 9) + (h >>> 17));
  }

  /**
   * Check for equality of non-null references x and y.
   * @param x 
   * @param y 
   * @return equality
   */
  protected boolean eq(Object x, Object y)
  {
    return x == y || x.equals(y);
  }

  /**
   * Constructs a new, empty map with the specified initial capacity and the
   * specified load factor.
   * 
   * @param initialCapacity
   *            the initial capacity The actual initial capacity is rounded to
   *            the nearest power of two.
   * @param loadFactor
   *            the load factor of the ConcurrentReaderHashMap
   * @throws IllegalArgumentException
   *             if the initial maximum number of elements is less than zero,
   *             or if the load factor is nonpositive.
   */
  public ConcurrentReaderHashMap(int initialCapacity, float loadFactor)
  {
    if (loadFactor <= 0)
    {
      throw new IllegalArgumentException("Illegal Load factor: " + loadFactor);
    }
    this.loadFactor = loadFactor;

    int cap = p2capacity(initialCapacity);

    table = new Entry[cap];
    threshold = (int)(cap * loadFactor);
  }

  /**
   * Constructs a new, empty map with the specified initial capacity and
   * default load factor.
   * 
   * @param initialCapacity
   *            the initial capacity of the ConcurrentReaderHashMap.
   * @throws IllegalArgumentException
   *             if the initial maximum number of elements is less than zero.
   */
  public ConcurrentReaderHashMap(int initialCapacity)
  {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
  }

  /**
   * Constructs a new, empty map with a default initial capacity and load
   * factor.
   */
  public ConcurrentReaderHashMap()
  {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
  }

  /**
   * Constructs a new map with the same mappings as the given map. The map is
   * created with a capacity of twice the number of mappings in the given map
   * or 16 (whichever is greater), and a default load factor.
   * @param t 
   */
  public ConcurrentReaderHashMap(Map t)
  {
    this(Math.max((int)(t.size() / DEFAULT_LOAD_FACTOR) + 1, 16), DEFAULT_LOAD_FACTOR);
    putAll(t);
  }

  /**
   * Returns the number of key-value mappings in this map.
   * 
   * @return the number of key-value mappings in this map.
   */
  public synchronized int size()
  {
    return count;
  }

  /**
   * Returns <tt>true</tt> if this map contains no key-value mappings.
   * 
   * @return <tt>true</tt> if this map contains no key-value mappings.
   */
  public synchronized boolean isEmpty()
  {
    return count == 0;
  }

  /**
   * Returns the value to which the specified key is mapped in this table.
   * 
   * @param key
   *            a key in the table.
   * @return the value to which the key is mapped in this table;
   *         <code>null</code> if the key is not mapped to any value in this
   *         table.
   * @exception NullPointerException
   *                if the key is <code>null</code>.
   * @see #put(Object, Object)
   */
  public Object get(Object key)
  {
    // throw null pointer exception if key null
    int hash = hash(key);

    /*
     * Start off at the apparently correct bin. If entry is found, we need
     * to check after a barrier anyway. If not found, we need a barrier to
     * check if we are actually in right bin. So either way, we encounter
     * only one barrier unless we need to retry. And we only need to fully
     * synchronize if there have been concurrent modifications.
     */

    Entry[] tab = table;
    int index = hash & (tab.length - 1);
    Entry first = tab[index];
    Entry e = first;

    for (;;)
    {
      if (e == null)
      {
        // If key apparently not there, check to
        // make sure this was a valid read

        Entry[] reread = getTableForReading();
        if (tab == reread && first == tab[index])
        {
          return null;
        }
        else
        {
          // Wrong list -- must restart traversal at new first
          tab = reread;
          e = first = tab[index = hash & (tab.length - 1)];
        }
      }
      else if (e.hash == hash && eq(key, e.key))
      {
        Object value = e.value;
        if (value != null)
        {
          return value;
        }

        // Entry was invalidated during deletion. But it could
        // have been re-inserted, so we must retraverse.
        // To avoid useless contention, get lock to wait out
        // modifications
        // before retraversing.

        synchronized (this)
        {
          tab = table;
        }
        e = first = tab[index = hash & (tab.length - 1)];
      }
      else
      {
        e = e.next;
      }
    }
  }

  /**
   * Tests if the specified object is a key in this table.
   * 
   * @param key
   *            possible key.
   * @return <code>true</code> if and only if the specified object is a key
   *         in this table, as determined by the <tt>equals</tt> method;
   *         <code>false</code> otherwise.
   * @exception NullPointerException
   *                if the key is <code>null</code>.
   * @see #contains(Object)
   */
  public boolean containsKey(Object key)
  {
    return get(key) != null;
  }

  /**
   * Maps the specified <code>key</code> to the specified <code>value</code>
   * in this table. Neither the key nor the value can be <code>null</code>.
   * <p>
   * 
   * The value can be retrieved by calling the <code>get</code> method with
   * a key that is equal to the original key.
   * 
   * @param key
   *            the table key.
   * @param value
   *            the value.
   * @return the previous value of the specified key in this table, or
   *         <code>null</code> if it did not have one.
   * @exception NullPointerException
   *                if the key or value is <code>null</code>.
   * @see Object#equals(Object)
   * @see #get(Object)
   */
  public Object put(Object key, Object value)
  {
    if (value == null)
    {
      throw new IllegalArgumentException("Value must not be null");
    }
    int hash = hash(key);
    Entry[] tab = table;
    int index = hash & (tab.length - 1);
    Entry first = tab[index];
    Entry e;

    for (e = first; e != null; e = e.next)
    {
      if (e.hash == hash && eq(key, e.key))
      {
        break;
      }
    }

    synchronized (this)
    {
      if (tab == table)
      {
        if (e == null)
        {
          // make sure we are adding to correct list
          if (first == tab[index])
          {
            // Add to front of list
            Entry newEntry = new Entry(hash, key, value, first);
            tab[index] = newEntry;
            if (++count >= threshold)
            {
              rehash();
            }
            else
            {
              recordModification(newEntry);
            }
            return null;
          }
        }
        else
        {
          Object oldValue = e.value;
          if (first == tab[index] && oldValue != null)
          {
            e.value = value;
            return oldValue;
          }
        }
      }

      // retry if wrong list or lost race against concurrent remove
      return sput(key, value, hash);
    }
  }

  /**
   * Continuation of put(), called only when synch lock is held and
   * interference has been detected.
   * @param key 
   * @param value 
   * @param hash 
   * @return continuation object
   */
  protected Object sput(Object key, Object value, int hash)
  {
    Entry[] tab = table;
    int index = hash & (tab.length - 1);
    Entry first = tab[index];
    Entry e = first;

    for (;;)
    {
      if (e == null)
      {
        Entry newEntry = new Entry(hash, key, value, first);
        tab[index] = newEntry;
        if (++count >= threshold)
        {
          rehash();
        }
        else
        {
          recordModification(newEntry);
        }
        return null;
      }
      else if (e.hash == hash && eq(key, e.key))
      {
        Object oldValue = e.value;
        e.value = value;
        return oldValue;
      }
      else
      {
        e = e.next;
      }
    }
  }

  /**
   * Rehashes the contents of this map into a new table with a larger
   * capacity. This method is called automatically when the number of keys in
   * this map exceeds its capacity and load factor.
   */
  protected void rehash()
  {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity >= MAXIMUM_CAPACITY)
    {
      threshold = Integer.MAX_VALUE; // avoid retriggering
      return;
    }

    int newCapacity = oldCapacity << 1;
    int mask = newCapacity - 1;
    threshold = (int)(newCapacity * loadFactor);

    Entry[] newTable = new Entry[newCapacity];
    /*
     * Reclassify nodes in each list to new Map. Because we are using
     * power-of-two expansion, the elements from each bin must either stay
     * at same index, or move to oldCapacity+index. We also eliminate
     * unnecessary node creation by catching cases where old nodes can be
     * reused because their next fields won't change. Statistically, at the
     * default threshhold, only about one-sixth of them need cloning. (The
     * nodes they replace will be garbage collectable as soon as they are no
     * longer referenced by any reader thread that may be in the midst of
     * traversing table right now.)
     */