geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bschucha...@apache.org
Subject [33/51] [partial] incubator-geode git commit: GEODE-77 removing the old jgroups subproject
Date Fri, 21 Aug 2015 21:22:57 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WaiterPreferenceSemaphore.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WaiterPreferenceSemaphore.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WaiterPreferenceSemaphore.java
deleted file mode 100644
index 8a0b248..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WaiterPreferenceSemaphore.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-/*
-  File: WaiterPreferenceSemaphore.java
-
-  Originally written by Doug Lea and released into the public domain.
-  This may be used for any purposes whatsoever without acknowledgment.
-  Thanks for the assistance and support of Sun Microsystems Labs,
-  and everyone contributing, testing, and using this code.
-
-  History:
-  Date       Who                What
-  11Jun1998  dl               Create public version
-   5Aug1998  dl               replaced int counters with longs
-*/
-
-
-package com.gemstone.org.jgroups.oswego.concurrent;
-
-/**
- * An implementation of counting Semaphores that
- *  enforces enough fairness for applications that
- *  need to avoid indefinite overtaking without
- *  necessarily requiring FIFO ordered access.
- *  Empirically, very little is paid for this property
- *  unless there is a lot of contention among threads
- *  or very unfair JVM scheduling.
- *  The acquire method waits even if there are permits
- *  available but have not yet been claimed by threads that have
- *  been notified but not yet resumed. This makes the semaphore
- *  almost as fair as the underlying Java primitives allow. 
- *  So, if synch lock entry and notify are both fair
- *  so is the semaphore -- almost:  Rewaits stemming
- *  from timeouts in attempt, along with potentials for
- *  interrupted threads to be notified can compromise fairness,
- *  possibly allowing later-arriving threads to pass before
- *  later arriving ones. However, in no case can a newly
- *  entering thread obtain a permit if there are still others waiting.
- *  Also, signalling order need not coincide with
- *  resumption order. Later-arriving threads might get permits
- *  and continue before other resumable threads are actually resumed.
- *  However, all of these potential fairness breaches are
- *  very rare in practice unless the underlying JVM
- *  performs strictly LIFO notifications (which has, sadly enough, 
- *  been known to occur) in which case you need to use
- *  a FIFOSemaphore to maintain a reasonable approximation
- *  of fairness.
- * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
-**/
-
-
-public final class WaiterPreferenceSemaphore extends Semaphore  {
-
-  /** 
-   * Create a Semaphore with the given initial number of permits.
-  **/
-
-  public WaiterPreferenceSemaphore(long initial) {  super(initial); }
-
-  /** Number of waiting threads **/
-  protected long waits_ = 0;   
-
-  @Override // GemStoneAddition
-  public void acquire() throws InterruptedException {
-    if (Thread.interrupted()) throw new InterruptedException();
-    synchronized(this) {
-      /*
-        Only take if there are more permits than threads waiting
-        for permits. This prevents infinite overtaking.
-      */ 
-      if (permits_ > waits_) { 
-        --permits_;
-        return;
-      }
-      else { 
-        ++waits_;
-        try { 
-          for (;;) {
-            wait(); 
-            if (permits_ > 0) {
-              --waits_;
-              --permits_;
-              return;
-            }
-          }
-        }
-        catch(InterruptedException ex) { 
-          --waits_;
-          notify();
-          throw ex;
-        }
-      }
-    }
-  }
-
-  @Override // GemStoneAddition
-  public boolean attempt(long msecs) throws InterruptedException {
-    if (Thread.interrupted()) throw new InterruptedException();
-
-    synchronized(this) {
-      if (permits_ > waits_) { 
-        --permits_;
-        return true;
-      }
-      else if (msecs <= 0)   
-        return false;
-      else {
-        ++waits_;
-        
-        long startTime = System.currentTimeMillis();
-        long waitTime = msecs;
-        
-        try {
-          for (;;) {
-            wait(waitTime);
-            if (permits_ > 0) {
-              --waits_;
-              --permits_;
-              return true;
-            }
-            else { // got a time-out or false-alarm notify
-              waitTime = msecs - (System.currentTimeMillis() - startTime);
-              if (waitTime <= 0) {
-                --waits_;
-                return false;
-              }
-            }
-          }
-        }
-        catch(InterruptedException ex) { 
-          --waits_;
-          notify();
-          throw ex;
-        }
-      }
-    }
-  }
-
-  @Override // GemStoneAddition
-  public synchronized void release() {
-    ++permits_;
-    notify();
-  }
-
-  /** Release N permits **/
-  @Override // GemStoneAddition
-  public synchronized void release(long n) {
-    permits_ += n;
-    for (long i = 0; i < n; ++i) notify();
-  }
-
-}
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WriterPreferenceReadWriteLock.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WriterPreferenceReadWriteLock.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WriterPreferenceReadWriteLock.java
deleted file mode 100644
index 9e9e4f6..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/WriterPreferenceReadWriteLock.java
+++ /dev/null
@@ -1,337 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-/*
-  File: WriterPreferenceReadWriteLock.java
-
-  Originally written by Doug Lea and released into the public domain.
-  This may be used for any purposes whatsoever without acknowledgment.
-  Thanks for the assistance and support of Sun Microsystems Labs,
-  and everyone contributing, testing, and using this code.
-
-  History:
-  Date       Who                What
-  11Jun1998  dl               Create public version
-   5Aug1998  dl               replaced int counters with longs
-  25aug1998  dl               record writer thread
-   3May1999  dl               add notifications on interrupt/timeout
-
-*/
-
-package com.gemstone.org.jgroups.oswego.concurrent;
-
-/** 
- * A ReadWriteLock that prefers waiting writers over
- * waiting readers when there is contention. This class
- * is adapted from the versions described in CPJ, improving
- * on the ones there a bit by segregating reader and writer
- * wait queues, which is typically more efficient.
- * <p>
- * The locks are <em>NOT</em> reentrant. In particular,
- * even though it may appear to usually work OK,
- * a thread holding a read lock should not attempt to
- * re-acquire it. Doing so risks lockouts when there are
- * also waiting writers.
- * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
- **/
-
-public class WriterPreferenceReadWriteLock implements ReadWriteLock {
-
-  protected long activeReaders_ = 0; 
-  protected Thread activeWriter_ = null;
-  protected long waitingReaders_ = 0;
-  protected long waitingWriters_ = 0;
-
-  protected final ReaderLock readerLock_ = new ReaderLock();
-  protected final WriterLock writerLock_ = new WriterLock();
-
-  public Sync writeLock() { return writerLock_; }
-  public Sync readLock() { return readerLock_; }
-
-  /*
-    A bunch of small synchronized methods are needed
-    to allow communication from the Lock objects
-    back to this object, that serves as controller
-  */
-
-
-  protected synchronized void cancelledWaitingReader() { --waitingReaders_; }
-  protected synchronized void cancelledWaitingWriter() { --waitingWriters_; }
-
-
-  /** Override this method to change to reader preference **/
-  protected boolean allowReader() {
-    return activeWriter_ == null && waitingWriters_ == 0;
-  }
-
-
-  protected synchronized boolean startRead() {
-    boolean allowRead = allowReader();
-    if (allowRead)  ++activeReaders_;
-    return allowRead;
-  }
-
-  protected synchronized boolean startWrite() {
-
-    // The allowWrite expression cannot be modified without
-    // also changing startWrite, so is hard-wired
-
-    boolean allowWrite = (activeWriter_ == null && activeReaders_ == 0);
-    if (allowWrite)  activeWriter_ = Thread.currentThread();
-    return allowWrite;
-   }
-
-
-  /* 
-     Each of these variants is needed to maintain atomicity
-     of wait counts during wait loops. They could be
-     made faster by manually inlining each other. We hope that
-     compilers do this for us though.
-  */
-
-  protected synchronized boolean startReadFromNewReader() {
-    boolean pass = startRead();
-    if (!pass) ++waitingReaders_;
-    return pass;
-  }
-
-  protected synchronized boolean startWriteFromNewWriter() {
-    boolean pass = startWrite();
-    if (!pass) ++waitingWriters_;
-    return pass;
-  }
-
-  protected synchronized boolean startReadFromWaitingReader() {
-    boolean pass = startRead();
-    if (pass) --waitingReaders_;
-    return pass;
-  }
-
-  protected synchronized boolean startWriteFromWaitingWriter() {
-    boolean pass = startWrite();
-    if (pass) --waitingWriters_;
-    return pass;
-  }
-
-  /**
-   * Called upon termination of a read.
-   * Returns the object to signal to wake up a waiter, or null if no such
-   **/
-  protected synchronized Signaller endRead() {
-    if (--activeReaders_ == 0 && waitingWriters_ > 0)
-      return writerLock_;
-    else
-      return null;
-  }
-
-  
-  /**
-   * Called upon termination of a write.
-   * Returns the object to signal to wake up a waiter, or null if no such
-   **/
-  protected synchronized Signaller endWrite() {
-    activeWriter_ = null;
-    if (waitingReaders_ > 0 && allowReader())
-      return readerLock_;
-    else if (waitingWriters_ > 0)
-      return writerLock_;
-    else
-      return null;
-  }
-
-
-  /**
-   * Reader and Writer requests are maintained in two different
-   * wait sets, by two different objects. These objects do not
-   * know whether the wait sets need notification since they
-   * don't know preference rules. So, each supports a
-   * method that can be selected by main controlling object
-   * to perform the notifications.  This base class simplifies mechanics.
-   **/
-
-  protected abstract class Signaller  { // base for ReaderLock and WriterLock
-    abstract public void signalWaiters(); // GemStoneAddition "public"
-  }
-
-  protected class ReaderLock extends Signaller implements Sync {
-
-    public  void acquire() throws InterruptedException {
-      if (Thread.interrupted()) throw new InterruptedException();
-      InterruptedException ie = null;
-      synchronized(this) {
-        if (!startReadFromNewReader()) {
-          for (;;) {
-            boolean interrupted = Thread.interrupted(); // GemStoneAddition
-            try { 
-              ReaderLock.this.wait();  
-              if (startReadFromWaitingReader())
-                return;
-            }
-            catch(InterruptedException ex){
-              interrupted = true;
-              cancelledWaitingReader();
-              ie = ex;
-              break;
-            }
-            finally { // GemStoneAddition
-              if (interrupted) Thread.currentThread().interrupt();
-            }
-          }
-        }
-      }
-      if (ie != null) {
-        // fall through outside synch on interrupt.
-        // This notification is not really needed here, 
-        //   but may be in plausible subclasses
-        writerLock_.signalWaiters();
-        throw ie;
-      }
-    }
-
-
-    public void release() {
-      Signaller s = endRead();
-      if (s != null) s.signalWaiters();
-    }
-
-
-    @Override // GemStoneAddition; also added "public"
-    synchronized public void signalWaiters() { ReaderLock.this.notifyAll(); }
-
-    public boolean attempt(long msecs) throws InterruptedException { 
-      if (Thread.interrupted()) throw new InterruptedException();
-      InterruptedException ie = null;
-      synchronized(this) {
-        if (msecs <= 0)
-          return startRead();
-        else if (startReadFromNewReader()) 
-          return true;
-        else {
-          long waitTime = msecs;
-          long start = System.currentTimeMillis();
-          for (;;) {
-            boolean interrupted = Thread.interrupted(); // GemStoneAddition
-            try { ReaderLock.this.wait(waitTime);  }
-            catch(InterruptedException ex){
-              interrupted = true;
-              cancelledWaitingReader();
-              ie = ex;
-              break;
-            }
-            finally {
-              if (interrupted) Thread.currentThread().interrupt();
-            }
-            if (startReadFromWaitingReader())
-              return true;
-            else {
-              waitTime = msecs - (System.currentTimeMillis() - start);
-              if (waitTime <= 0) {
-                cancelledWaitingReader();
-                break;
-              }
-            }
-          }
-        }
-      }
-      // safeguard on interrupt or timeout:
-      writerLock_.signalWaiters();
-      if (ie != null) throw ie;
-      else return false; // timed out
-    }
-
-  }
-
-  protected class WriterLock extends Signaller implements  Sync {
-
-    public void acquire() throws InterruptedException {
-      if (Thread.interrupted()) throw new InterruptedException();
-      InterruptedException ie = null;
-      synchronized(this) {
-        if (!startWriteFromNewWriter()) {
-          for (;;) {
-            boolean interrupted = Thread.interrupted(); // GemStoneAddition
-            try { 
-              WriterLock.this.wait();  
-              if (startWriteFromWaitingWriter())
-                return;
-            }
-            catch(InterruptedException ex){
-              interrupted = true;
-              cancelledWaitingWriter();
-              WriterLock.this.notify();
-              ie = ex;
-              break;
-            }
-            finally {
-              if (interrupted) Thread.currentThread().interrupt();
-            }
-          }
-        }
-      }
-      if (ie != null) {
-        // Fall through outside synch on interrupt.
-        //  On exception, we may need to signal readers.
-        //  It is not worth checking here whether it is strictly necessary.
-        readerLock_.signalWaiters();
-        throw ie;
-      }
-    }
-
-    public void release(){
-      Signaller s = endWrite();
-      if (s != null) s.signalWaiters();
-    }
-
-    @Override // GemStoneAddition; also added "public"
-    synchronized public void signalWaiters() { WriterLock.this.notify(); }
-
-    public boolean attempt(long msecs) throws InterruptedException { 
-      if (Thread.interrupted()) throw new InterruptedException();
-      InterruptedException ie = null;
-      synchronized(this) {
-        if (msecs <= 0)
-          return startWrite();
-        else if (startWriteFromNewWriter()) 
-          return true;
-        else {
-          long waitTime = msecs;
-          long start = System.currentTimeMillis();
-          for (;;) {
-            boolean interrupted = Thread.interrupted(); // GemStoneAddition
-            try { WriterLock.this.wait(waitTime);  }
-            catch(InterruptedException ex){
-              interrupted = true;
-              cancelledWaitingWriter();
-              WriterLock.this.notify();
-              ie = ex;
-              break;
-            }
-            finally {
-              if (interrupted) Thread.currentThread().interrupt();
-            }
-            if (startWriteFromWaitingWriter())
-              return true;
-            else {
-              waitTime = msecs - (System.currentTimeMillis() - start);
-              if (waitTime <= 0) {
-                cancelledWaitingWriter();
-                WriterLock.this.notify();
-                break;
-              }
-            }
-          }
-        }
-      }
-      
-      readerLock_.signalWaiters();
-      if (ie != null) throw ie;
-      else return false; // timed out
-    }
-
-  }
-
-
-
-}
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/package.html
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/package.html b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/package.html
deleted file mode 100644
index 4bc83d8..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/oswego/concurrent/package.html
+++ /dev/null
@@ -1,998 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd"><html>
-<head>
-  <title>
-   Overview of package util.concurrent Release 1.3.4.
-  </title>
-</head>
-<body bgcolor="#ffffee" vlink="#0000aa" link="#cc0000">
-<h1>Overview of package util.concurrent Release 1.3.4.</h1>
-
-  by <a href="http://gee.cs.oswego.edu/dl">Doug Lea</a>
-  <p>
-
-Note: Upon release of J2SE 1.5, this package enters maintenance mode:
-Only essential corrections will be released. JDK1.5 package <a
-href="http://gee.cs.oswego.edu/dl/concurrency-interest/index.html">
-java.util.concurrent </a> includes improved, more efficient,
-standardized versions of the main components in this package. Please
-plan to convert your applications to use them. (A few niche classes
-here have no equivalents in java.util.concurrent. They will become
-part of a follow-up add-on package that will also include other
-unstandardized classes.)
-
-
-<p>
-   This package provides standardized, efficient versions of utility
-   classes commonly encountered in concurrent Java programming.  This
-   code consists of implementations of ideas that have been around for
-   ages, and is merely intended to save you the trouble of coding them.
-   Discussions of the rationale and applications of several of these
-   classes can be found in the second edition of <a href="http://gee.cs.oswego.edu/dl/cpj">Concurrent Programming in
-   Java</a>.  There are also <a href="http://gee.cs.oswego.edu/dl/cpjslides/util.pdf">pdf
-   slides</a> providing an overview of the package.
-    </a>
-
-  </p><p>
-   The package mainly consists of implementations of a few interfaces:
-   <br>
-  </p><ul>
-   <li><code>Sync</code> -- locks, conditions <br>
-   </li><li><code>Channel</code> -- queues, buffers <br>
-   </li><li><code>Barrier</code> -- multi-party synchronization <br>
-
-   </li><li><code>SynchronizedVariable</code> -- atomic ints, refs etc <br>
-
-   </li><li><code>java.util.Collection</code> -- collections <br>
-
-   </li><li><code>Executor</code> -- replacements for direct use of Thread <br>
-  </li></ul>
-   
-   Plus some utilities and frameworks that build upon these.
-  <p>
-   If you arrived at page<br>
-   http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html
-   <br>
-   following links from your local documentation, please check the
-   version number and get an update if you are running an outdated
-   version.
-
-
-</p><h2>Installation</h2>
-
-  This package, currently declared as
-  <blockquote>
-   <code>EDU.oswego.cs.dl.util.concurrent</code> 
-  </blockquote>
-
-  is available in (<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/current/concurrent.tar.gz">tar.gz
-format</a>) or (<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/current/concurrent.zip">zip
-format</a>).
-
-  <p>
-
-  It is currently distributed in source form only. To build it, use a
-   Java 1.2+ compiler to:
-</p><pre>  javac -d <em>[SOMEWHERE IN YOUR CLASSPATH]</em> *.java
-</pre>
-  Or use this <a href="build.xml" >ant build file</a> donated by
-  Travell Perkins.
-  <p>
-   The classes in the <code>misc</code> directory can be built the
-   same way.
-  </p><p>
-   To use it, add to java files:
-</p><pre>  import EDU.oswego.cs.dl.util.concurrent.*
-</pre>
-  <p> You can also create a jar or zip file of the compiled classes
-   and add them to your classpath.
-  </p><p>
-   All <a href="http://gee.cs.oswego.edu/dl/classes/index.html"> documentation</a>
-    except for this file was produced by javadoc, which
-    places some index and summary files outside the current
-    directory. This can cause some broken links on unpacked versions.
-    You can avoid this, and integrate with your local javadoc-produced
-    documentation by running:
-</p><pre>  javadoc -public -d <em>[BASE OF SOME JAVADOC PATH]</em> *.java
-</pre>
- 
-<h2>Contents</h2>
-  
-  <dl><dt><b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/EDU/oswego/cs/dl/util/concurrent/Sync.html">Sync</a> </b>
-
-   </dt><dd>Interface for classes used as exclusion, resource management,
-   and related synchronization aids, supporting methods
-   <code>acquire</code>, <code>attempt(msecs)</code>, and
-   <code>release</code>.
-    <p>
-     <b>Implementations</b>
-
-    </p></dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Semaphore.html">Semaphore</a>
-     </dt><dd>Default implementation of Semaphores, providing no 
-      special ordering guarantees. 
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaiterPreferenceSemaphore.html">WaiterPreferenceSemaphore</a>
-     </dt><dd>Provides protection against barging (infinite overtaking)
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FIFOSemaphore.html">FIFOSemaphore</a>
-     </dt><dd>Provides first-in/first-out ordering
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PrioritySemaphore.html">PrioritySemaphore</a>
-     </dt><dd>Prefers notifications to higher-priority threads
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Mutex.html">Mutex</a>
-     </dt><dd>Basic non-reentrant mutual exclusion lock
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReentrantLock.html">ReentrantLock</a>
-     </dt><dd>Java-style per-thread mutual exclusion lock
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Latch.html">Latch</a>
-     </dt><dd>A condition that is acquirable forever more after the first release
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CountDown.html">CountDown</a>
-     </dt><dd>A condition that is acquirable forever more after the <em>nth</em> 
-      release.
-    </dd></dl><p>
- 
-    The following implementation classes do not themselves perform any
-    synchronization, but serve as adaptors, glue, and extensibility
-    hooks for those that do. They may also be helpful when using Syncs
-    in generic before/after constructions:
-
-    </p><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/NullSync.html">NullSync</a>
-     </dt><dd>A no-op implementation: acquire and attempt always succeed.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimeoutSync.html">TimeoutSync</a>
-     </dt><dd>Routes all calls to acquire to use attempt with a predefined
-      timeout value.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LayeredSync.html">LayeredSync</a>
-     </dt><dd>Cascades operations of two Syncs
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ObservableSync.html">ObservableSync</a>
-     </dt><dd>Issues calls to SyncObservers upon each acquire and release.
-    </dd></dl><p>
-     <b>Related Classes</b>
-    </p><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CondVar.html">CondVar</a>
-     </dt><dd>Support for POSIX (pthreads) style condition variables
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimeoutException.html">TimeoutException</a>
-     </dt><dd>A standardized time-out exception class
-    </dd></dl><p></p><p>
-
-
-   </p><dt><b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReadWriteLock.html">ReadWriteLock</a></b>
-   </dt><dd>Interface for pairs of locks, one for reading, and one for
-   writing.
-
-    <p>
-     <b>Implementations</b>
-    </p></dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WriterPreferenceReadWriteLock.html">WriterPreferenceReadWriteLock</a>
-     </dt><dd>The most useful and common policy
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReentrantWriterPreferenceReadWriteLock.html">ReentrantWriterPreferenceReadWriteLock</a>
-     </dt><dd>Allows multiple lock holds as well as lock downgrading by writers.
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReaderPreferenceReadWriteLock.html">ReaderPreferenceReadWriteLock</a>
-     </dt><dd>Prefers waiting readers to waiting writers.
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FIFOReadWriteLock.html">FIFOReadWriteLock</a>
-     </dt><dd>Prefers earliest threads (whether readers or writers).
-    </dd></dl><p>
-
-   </p><dt><b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Barrier.html">Barrier</a></b>
-   </dt><dd> Synchronization points for groups of threads. 
-    <p>
-     <b>Implementations</b>
-    </p></dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CyclicBarrier.html">CyclicBarrier</a>
-     </dt><dd> A tool to force multiple threads to synchronize at a given point
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Rendezvous.html">Rendezvous</a>
-     </dt><dd>A cyclic barrier that does not rely on there being a
-      predetermined number of participant threads, and allows threads
-      to exchange information at each barrier point.
-    </dd></dl><p>
-     <b>Related Classes</b>
-    </p><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BrokenBarrierException.html">BrokenBarrierException</a>
-     </dt><dd>A standardized exception for barrier synchronization failures
-    </dd></dl><p>
-
-   </p><dt><b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Channel.html">Channel</a></b> 
-
-   </dt><dd> Interface for queues, buffers, conduits and pipes supporting
-    blocking <code>put</code> and <code>take</code>, as well as
-    timeout-based <code>offer</code> and <code>poll</code>.  To assist
-    efforts to use channels with somewhat greater type safety, Channel
-    is defined as a subinterface of <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Puttable.html">Puttable</a> and <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Takable.html">Takable</a>, each defining only one side of
-    the channel.  Also, the <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedChannel.html">BoundedChannel</a> subinterface is used
-    for channels with finite capacities.
-    <p>
-     <b>Implementations</b>
-
-    </p></dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LinkedQueue.html">LinkedQueue</a>
-     </dt><dd>An unbounded linked-list-based queue. This is usually the
-     best choice for a general-purpose queue.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedLinkedQueue.html">BoundedLinkedQueue</a>
-     </dt><dd>A linked queue with a capacity bound
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedBuffer.html">BoundedBuffer</a>
-     </dt><dd>An array-based bounded buffer
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Slot.html">Slot</a>
-     </dt><dd>A one-slot bounded buffer. (Note that this can also
-      serve as a restricted form of Synchronized variable.)
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronousChannel.html">SynchronousChannel</a>
-     </dt><dd>A zero-slot CSP/Ada-style channel in which every put must
-      wait for a take, and vice versa.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedPriorityQueue.html">BoundedPriorityQueue</a>
-     </dt><dd>A channel based on a Heap data structure. Elements
-      must either be Comparable, or comparable using a supplied Comparator
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitFreeQueue.html">WaitFreeQueue</a>
-     </dt><dd>An unbounded linked-list-based queue relying on atomic
-      commits and retries rather than wait/notify.
-
-    </dd></dl><p>
-     <b>Related Classes</b>
-    </p><dl><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/DefaultChannelCapacity.html">DefaultChannelCapacity</a>
-     </dt><dd> A utility class that makes it easier to set default
-      capacities for channels that have a capacity that must otherwise
-      be set in constructors.
-    </dd></dl><p>
-
-   </p><dt><b> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Executor.html">Executor</a></b>
-   </dt><dd> Interface for objects that <code>execute</code> Runnable commands.
-
-    <p>
-     <b>Implementations</b>
-    </p></dd><dl><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/DirectExecutor.html">DirectExecutor</a>
-     </dt><dd> An implementation that just directly runs command
-      in current thread.
-
-     </dd><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LockedExecutor.html">LockedExecutor</a>
-     </dt><dd> An implementation that directly runs command
-      within a supplied Sync lock in current thread.
-
-     </dd><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadedExecutor.html">ThreadedExecutor</a>
-     </dt><dd> An implementation that runs each command
-      in a new thread.
-
-     </dd><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/QueuedExecutor.html">QueuedExecutor</a>
-     </dt><dd> An implementation that queues commands for execution
-      by a single background thread.
-
-     </dd><dt> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PooledExecutor.html">PooledExecutor</a>
-     </dt><dd>A tunable, extensible thread pool class
-    </dd></dl><p>
-    <b>Related classes</b>
-    </p><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Callable.html">Callable</a>
-     </dt><dd>Interface for runnable actions that return results
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FutureResult.html">FutureResult</a>
-     </dt><dd>Holder for results of actions that can be set by Callables.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadFactory.html">ThreadFactory</a>
-     </dt><dd>Interface for objects that create Thread objects
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadFactoryUser.html">ThreadFactoryUser</a>
-     </dt><dd>Convenient base for classes that use ThreadFactories.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ClockDaemon.html">ClockDaemon</a>
-     </dt><dd> A utility for executing commands at given times,
-      after given delays, or periodically with given cycles.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimedCallable.html">TimedCallable</a>
-     </dt><dd>Invokes a Callable in its own thread, but cancels it if not
-      completed by a given maximum time.
-    </dd></dl><p>
-
-   </p><dt> <b>Fork/Join Tasks</b>
-
-   </dt><dd> A fast lightweight task framework built upon Java threads, and
-   geared for parallel computation. 
-
-    </dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTask.html">FJTask</a>
-     </dt><dd>Abstract Base class for tasks.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTaskRunnerGroup.html">FJTaskRunnerGroup</a>
-     </dt><dd>Control class for running Tasks.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTaskRunner.html">FJTaskRunner</a>
-     </dt><dd>Underlying specialized Thread subclass for running Tasks.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/taskDemo/demos.html">Demos and examples</a>
-     </dt><dd>A directory of sample programs that use the Task framework.
-      (See also a paper on <a href="http://gee.cs.oswego.edu/dl/papers/fj.pdf">the design and
-      performance of this framework</a>.)
-      
-    </dd></dl><p>
-
-
-   </p><dt> <b>Collections</b>
-   </dt><dd> Implementations of java.util.Collection and related classes that
-    can help solve concurrency problems. 
-    </dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ConcurrentReaderHashMap.html">ConcurrentReaderHashMap</a>
-     </dt><dd>An analog of java.util.Hashtable that allows retrievals
-      during updates.
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ConcurrentHashMap.html">ConcurrentHashMap</a>
-     </dt><dd>An analog of java.util.Hashtable that allows 
-      both concurrent retrievals and concurrent updates.
-
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.html">CopyOnWriteArrayList</a>
-     </dt><dd>A copy-on-write analog of java.util.ArrayList 
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArraySet.html">CopyOnWriteArraySet</a>
-     </dt><dd>A java.util.Set based on CopyOnWriteArrayList.
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncCollection.html">SyncCollection</a>
-     </dt><dd>A wrapper class placing either Syncs or ReadWriteLocks 
-      around java.util.Collection
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSet.html">SyncSet</a>
-     </dt><dd>A wrapper around java.util.Set
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSortedSet.html">SyncSortedSet</a>
-     </dt><dd>A wrapper around java.util.SortedSet
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncList.html">SyncList</a>
-     </dt><dd>A wrapper around java.util.List
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncMap.html">SyncMap</a>
-     </dt><dd>A wrapper around java.util.Map
-     </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSortedMap.html">SyncSortedMap</a>
-     </dt><dd>A wrapper around java.util.SortedMap
-     </dd><dt><b>Related classes</b>
-     </dt><dd> 
-      </dd><dl><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PropertyChangeMulticaster.html">PropertyChangeMulticaster</a>
-       </dt><dd>A copy-on-write replacement for java.beans.PropertyChangeSupport
-       </dd><dt><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/VetoableChangeMulticaster.html">VetoableChangeMulticaster</a>
-       </dt><dd>A copy-on-write replacement for java.beans.VetoableChangeSupport
-
-    </dd></dl></dl><p>
-
-   </p><dt> <b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedVariable.html">SynchronizedVariable</a></b>
-
-   </dt><dd> Simple synchronized analogs of Number and Ref classes in
-   java.lang. Each has a subclass that in addition to maintaining
-   synchronization, also provides notifications upon value changes and
-   supports guarded waits.
-    <ul>
-     <li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedRef.html">SynchronizedRef</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableRef.html">WaitableRef</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedInt.html">SynchronizedInt</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableInt.html">WaitableInt</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedLong.html">SynchronizedLong</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableLong.html">WaitableLong</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedFloat.html">SynchronizedFloat</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableFloat.html">WaitableFloat</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedDouble.html">SynchronizedDouble</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableDouble.html">WaitableDouble</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedBoolean.html">SynchronizedBoolean</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableBoolean.html">WaitableBoolean</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedByte.html">SynchronizedByte</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableByte.html">WaitableByte</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedChar.html">SynchronizedChar</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableChar.html">WaitableChar</a>
-     </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedShort.html">SynchronizedShort</a> and
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableShort.html">WaitableShort</a>
-    </li></ul>
-    <p>
-
-    </p></dd><dt> <b><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc">Miscellany</a></b>
-
-    </dt><dd> There are some classes in the <code>misc</code> directory
-    that might be of interest but aren't really part of this
-    package. They include:
-    <ul>
-     <li> <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc/SynchronizationTimer.html">SynchronizationTimer</a>,
-    that can be used to experiment with different synchronization
-    schemes. It requires Swing (JFC). (To run it, compile misc/*.java, and
-    then java EDU.oswego.cs.dl.util.concurrent.misc.SynchronizationTimer .)
-     </li><li>An immutable <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc/Fraction.html">Fraction</a> class.
-     </li><li>Joe Bowbeer's 
-      <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc/SwingWorker.html">SwingWorker</a>
-      class,  discussed in his
-      <a href="http://java.sun.com/products/jfc/tsc/articles/threads/threads3.html#swing-worker">"The Last Word in Swing Threads"</a> article.
-     </li><li>Other implementations of the above interfaces that 
-      are not valuable or stable enough to include here.
-    </li></ul>
-    If you would like to contribute other related classes, demos,
-    usage examples, etc., please contact me. People frequently write
-    me asking for such things.
-  </dd></dl>
-
-
-
-  <h2>Notes</h2>
-  <ul>
-
-   <li>All classes are released to the public domain and may be used
-   for any purpose whatsoever without permission or
-   acknowledgment. Portions of the CopyOnWriteArrayList and
-   ConcurrentReaderHashMap classes are adapted from Sun JDK source
-   code. These are copyright of Sun Microsystems, Inc, and are used
-   with their kind permission,  <a href="../sun-u.c.license.pdf" >
-   as described in this license</a>.
-
-    <p>
-
-   </p></li><li>Version numbers for this package are of the form
-   Major.minor.fix. Fix numbers reflect corrections of small errors
-   and release problems (missing files, portability enhancements,
-   etc). Minor numbers are incremented on additions. Major numbers
-   reflect serious incompatibilities and restructurings.  I may also
-   sometimes make minor updates to this page and related files before
-   packaging up all files as a release. During early releases of added
-   classes, I expect to make frequent small changes and releases, as
-   soon as problems are noticed. Other ongoing changes are reflected
-   in individual source files, that you can get individual updates on
-   if you need them.
-    <p>
-
-   </p></li><li>Most of the interfaces and classes contain usage notes and
-   examples. I hope to add more.  Please send suggestions to <a href="mailto:dl@cs.oswego.edu">dl@cs.oswego.edu</a>
-    <p>
-
-   </p></li><li> You can get e-mail notification when this page (or any other
-   URL for that matter) changes via <a href="http://www.changedetection.com/">ChangeDetecion.com</a> or
-   other such services.
-    <p>
-
-   </p></li><li>These have been tested with JDK1.2+, but all except those
-   relying on JDK1.2 java.util.collections (i.e., BoundedPriorityQueue
-   and CopyOnWriteArrayList) should also work with
-   JDK1.1.x. Workarounds exist for those relying on collections by
-   obtaining the <a href="http://java.sun.com/beans/infobus/#DOWNLOAD_COLLECTIONS">backported
-   1.1 versions</a> and follow the <a href="http://java.sun.com/beans/infobus/collectionsreadme.html">instructions.
-</a>
-  You can then use "sed" or somesuch to replace all occurrences of
-   "java.util." with "com.sun.java.util".  Also, I'm told that some
-   1.1 compilers have some problems compiling some of the blank finals
-   used. And while the 1.1port of collections also includes a
-   1.2-compliant version of java.util.Random, you can alternatively
-   use the following version contributed by Andrew Cooke:
-
-<pre>package EDU.oswego.cs.dl.util.concurrent ;
-
-class Random extends java.util.Random {
-
-� public Random() {super() ;}
-� public Random(long l) {super(l) ;}
-
-� public int nextInt(int i) {
-��� int ii = (int)(i * nextDouble()) ;
-��� if (ii &gt;= i) {ii = i-1 ;} // should (almost?) never happen...
-��� return ii ;
-� }
-
-}
-</pre>
-    <p>
-
-    Konstantin L�ufer has generously placed a version compiled for JDK1.1 
-    at <a href="http://www.cs.luc.edu/%7Elaufer/courses/337/handouts/concurrent11.zip">http://www.cs.luc.edu/~laufer/courses/337/handouts/concurrent11.zip</a>
-    </p><p>
-
-   </p></li><li>Many of these classes are adapted from versions described in
-   the second edition of <a href="http://gee.cs.oswego.edu/dl/cpj">
-   Concurrent Programming in Java</a> (CPJ) and examples from
-   tutorials based on the book.
-    <p>
-
-   </p></li><li>Several classes were developed with the help of <a href="http://www.mri.mq.edu.au/%7Edholmes">David Holmes</a> and <a href="http://ourworld.compuserve.com/homepages/jozart/">Joe
-   Bowbeer</a>. Many have benefited from discussions and comments from
-   other people, including Tom Cargill, Tom May, Wayne Boucher,
-   Matthias Ernst, Michael Banks, Richard Emberson, Piotr Kaminski,
-   Bill Pugh, Peter Buhr, Alexander Terekhov, Alex Yiu-Man Chan,
-   Andrew Kelly, Markos Kapes, Boris Dimitshteyn.
-
-  </li></ul>
-   
-<h2>Some Questions and Answers about Design and Implementation</h2>
-
-  <dl><dt>Isn't it annoying that so many methods throw InterruptedException?
-
-   </dt><dd> Maybe, but synchronization points are among the best points to
-   detect interruption. Since this a package of synchronization aids,
-   most methods detect interruption as early and often as reasonable
-   to help avoid becoming stuck when the thread should be stopping
-   anyway. In particular, interruption is normally checked before
-   trying to obtain locks used in Syncs, which minimizes the
-   vulnerability window for getting stuck when an activity is
-   cancelled.  (Between this and the finite durations that internal
-   java synchronization locks are held in Sync classes, it is normally
-   impossible for threads to become stuck waiting on internal locks
-   when they have been interrupted.)  These classes fail cleanly upon
-   interruption. Normally, all you need to do upon catching an
-   InterruptedException is either rethrow it, or clean up and then set
-    <code>Thread.currentThread().interrupt()</code> to propagate
-    status.
-    <p>
-
-  If you need to invoke such methods even when the thread is in an
-  interrupted state (for example, during recovery actions) you can do:
-</p><pre>  void quietlyAcquire(Sync sync) {
-    boolean wasInterrupted = Thread.interrupted(); // record and clear
-    for (;;) {
-      try {
-        sync.acquire();   // or any other method throwing InterruptedException
-        break;
-      }
-      catch (InterruptedException ex) { // re-interrupted; try again
-        wasInterrupted = true;
-      }
-    }
-    if (wasInterrupted) {              // re-establish interrupted state
-      Thread.currentThread().interrupt();
-    }
- }
-</pre>
-    <p>
-     The heavy use of InterruptedException makes it possible to write
-     very responsive and robust code, at the expense of forcing class
-     and method authors to contemplate possible exception handling
-     actions at each interruption (and time-out) point. See the <a href="http://gee.cs.oswego.edu/dl/cpj/cancel.html">CPJ supplement
-     page on cancellation</a> for more discussion of some associated
-     design issues.
-
-    </p><p>
-
-   </p></dd><dt>Why is there so much near-duplication of code?
-
-   </dt><dd> You'd think there would be some nice way to unify more classes
-   to share significant aspects of synchronization mechanics.  But
-   standard lines of attack for doing this turn out unsatisfying at
-   best.  The main reason for creating this package is that even
-   simple classes involving concurrency control mechanics are
-   sometimes tedious, repetitive, tricky, and/or error-prone to write,
-   so it is nice to have them written already.
-    <p>
-
-   </p></dd><dt>Why do most methods return false/null after timeouts rather
-   than throwing TimeoutException?
-
-   </dt><dd> Because I think it would normally be misleading to throw
-   exceptions. In Java, timeout arguments merely provide hints about
-   when threads should be woken to check out the state of the world.
-   Due to scheduling delays, threads need not resume immediately after
-   their timeouts elapse, so real-time-based timeout exceptions would
-   not be appropriate. The simplest course of action is just to report
-   whether the condition the thread is waiting for does hold after
-   waiting for at least this period. Returning false/null is not
-   necessarily an exceptional situation.  In those classes where it is
-   exceptional (in some classes layered on top of basic Syncs and
-   Channels) failed timeouts are converted to TimeoutExceptions. You
-   can do the same in your own code using these classes. As of version
-   1.1.0, this is made simpler to carry out, since TimeoutException
-   now extends InterruptedException.
-    <p>
-
-   </p></dd><dt>Why aren't there deadlock-detecting Syncs or related classes for
-    detecting lockups?
-
-   </dt><dd>Because timeouts appear to be more generally useful. In fact,
-   it is hard to imagine contexts where deadlock detection is a better
-   option than timeouts in Java. A timeout can serve as a heuristic
-   deadlock detection device, but can also serve to detect stalled IO,
-   network partitions, and related failures. Program responses to
-   deadlock are hardly ever different than responses to these other
-   failures. So, it is usually a good idea to use timeouts as
-   general-purpose heuristic detectors for all liveness problems,
-   subdividing responses to particular failures (for example, by
-   subclassing TimeoutException), only when necessary. Additionally,
-   there are two problems with implementing deadlock-detecting Syncs
-   that make them unattractive choices: (1) They can only detect
-   deadlock among uses of the particular Sync classes being used, so
-   cannot deal with deadlocks involving builtin synchronization (2)
-   lock cycle detection adds overhead to each lock acquire and
-   release.  The main context in which deadlock detection would be
-   useful is during program debugging, but here, it would be better to
-   rely on specially instrumented JVMs. (Note that it is easy to
-   transform code that relies on acquire to instead use timeouts via
-   the TimeoutSync class. This can be a good way to make code more
-   robust with respect to locking problems.)
-    <p>
-
-   </p></dd><dt> Why isn't there a distinct Lock or MutualExclusionLock interface?
-
-   </dt><dd> Because many objects implementing the Sync interface can be
-   used as locks if they are in appropriate states, but not all of
-   them can always be used as such. Additionally, there are several
-   senses of mutual exclusion (for example, reentrant vs
-   non-reentrant, full vs read/write).  Since there is no way to say
-   that a given class only sometimes conforms to the intended sense of
-   a subinterface, the flexibility and simplicity of only using a
-   single principle interface (Sync) for all such types outweighs the
-   potential advantages of finer-grained categorizations.
-    <p>
-
-    </p></dd><dt> Why do so many methods perform notify within InterruptedException 
-    catches?
-    
-    </dt><dd> Because when notify's and interrupt's happen at about the
-    same time, JVMs are currently free to treat them independently, so
-    a notified thread could return out as interrupted.  In classes
-    using notify rather than notifyAll, the extra notify in the catch
-    clause is a safeguard to ensure that a non-interrupted thread, if
-    one exists, will be notified. See my CPJ book for more details.
-    <p>
-
-   </p></dd><dt> How efficient are these classes?
-
-   </dt><dd> Most of these classes use the most efficient implementations I
-   know of for general-purpose concurrent programming, yet also try to
-   be conservative about differences across common JVMs, and to
-   minimize surprising limitations and side-effects.  This is always a
-   bit of a trade-off though. Some could be made more efficient at the
-   cost of supporting fewer operations, relying on properties of
-   particular JVMs, or having more usage constraints. Conversely some
-   could support more contexts or operations, or simpler usage, at the
-   cost of efficiency.
-
-    <p>
-
-     You will almost surely trade off some cost in efficiency for the
-     flexibility of using Syncs and classes built out of them rather
-     than built-in <code>synchronized</code> method/block locks. On
-     some JVMs the cost is very low. (You can check approximate impact
-     using <a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/misc/SynchronizationTimer.html">SynchronizationTimer</a>.)
-     But, while Java VMs are getting much faster about
-     <code>synchronized</code> locks, most of the classes in this
-     package rely heavily on wait/notify and interruption mechanics,
-     which are not currently as heavily optimized. (Also, they seem to
-     be subject to more variation in behavior than other Java
-     constructs.)  Class implementations generally ignore the fact
-     that the JVM overhead for these operations might be slower than
-     you'd wish they were on some JVMs.
-
-    </p><p>
-
-   </p></dd><dt> Are there any programming errors?
-
-   </dt><dd> I don't believe so. Please try to prove me wrong. If you are
-    the first person to discover a particular coding error in a
-    current release, I'll send you a free copy of my CPJ book.  Also,
-    I would greatly appreciate receiving any sample applications that
-    can help serve as useful tests, so as to build up a more extensive
-    test suite.
-    <p>
-
-   </p></dd><dt> Should I worry about the use of <tt>volatile</tt> in these
-   classes?
-
-   </dt><dd> Many JVMs are known not to correctly implement the JLS spec
-   (either the original or the upcoming revision) for volatile fields.
-   However, volatiles are used in conservative ways in this package,
-   that don't encounter problems at least on recent Sun and IBM JVMs.
-
-    <p>
-
-
-   </p></dd><dt> Why do classes declare practically all internal matters as
-    <code>protected</code>?
-
-   </dt><dd> While probably 99% of the uses of these classes should
-   just treat them as black-box utility components, these classes are
-   intended to be extensible, to allow more specialized
-   synchronization control to be customized for different
-   applications.  However, it takes a lot of expertise to extend or
-   modify most of them via subclassing. If you do try to extend,
-   consider first running javadoc on these classes with switches that
-   generate documentation for non-public classes, methods, and
-   fields. Also, if you encounter problems making subclasses due to
-   inflexibility in base classes, I'd like to hear about it, so I can
-   try to come up with a better factoring.
-    <p>
-
-    </p></dd><dt> Why aren't most classes <code>Serializable</code>?
-    </dt><dd> I don't know what to about this. On one hand, it wouldn't
-    make sense in a lot of contexts to serialize, say, a Semaphore. On
-    the other hand, maybe it ought not be precluded.  Opinions
-    welcome. One suggestion is to only declare as serializable those
-    classes specifically designed to work with other persistent or
-    distributed concurrency control frameworks. (No such classes
-    currently exist.)
-    <p>
-
-    </p></dd><dt> Why didn't using ReadWriteLocks instead of plain
-    synchronization speed up my program?
-    </dt><dd> ReadWriteLocks have more overhead than do synchronized
-    methods or blocks.  They pay off only when the code being
-    protected by the locks is time-consuming, and when readers
-    outnumber writers, so the increased concurrency outweighs the
-    increased bookkeeping.  (They are also sometimes of use in
-    avoiding deadlock.)  Special-purpose data structures such as the
-    Concurrent hash tables in this package have far less overhead, and
-    typically much better performance than placing ReadWriteLocks
-    around most sequential data structures.
-    <p>
-
-   </p></dd><dt>Are instances of these classes externally lockable -- that is,
-    can I control object <code>x</code> via <code>synchronized(x) {
-    ... }</code> ?
-   </dt><dd> Not necessarily. Some objects rely on their own
-    synchronization locks, some rely on internal locks, some rely on
-    other synchronization objects.  So in general, you cannot know the
-    effect of <code>synchronized(x)</code> and so probably ought never
-    use it.
-    <p>
-
-   </p></dd><dt> Why do I get strict alternation of producer and consumer
-    threads when using buffered channels such as BoundedBuffer?
-
-   </dt><dd> Although it depends on details of JVM scheduling policies,
-   this is the most likely result when producer and consumer actions
-   both take about the same amount of time to process, since both put
-   and take operations signal waiting threads. The point of buffering
-   is to decouple producers and consumers when one or the other is
-   bursty, so temporarily gets ahead or behind its average rate. (If
-   the average rates of producers and consumers are not approximately
-   equal, buffering is not of much use.) While it again relies on JVM
-   details, unbounded buffers (for example LinkedQueue) typically do
-   not result in alternation, allowing producers to get arbitrarily
-   ahead of consumers, at the expense of potential resource
-   exhaustion.
-
-    <p>
-
-   </p></dd><dt>Why aren't there timeout methods supporting nanosecond
-   arguments?
-   </dt><dd> Because most JVMs only time to millisecond accuracy (at best)
-    anyway.  If this changes, nanosecond versions could be added.
-    <p>
-
-   </p></dd><dt>Why is the package named <code>EDU</code>..., not <code>edu</code>?
-   </dt><dd>I've been using the initially-recommended upper-case EDU prefix
-    for a long time for my packages. It would take a lot of busy-work
-    to convert everything to the now-recommended practice of using
-    lower-case. Someday I will do this though.
-
-    <p>
-
-
-   </p></dd><dt> Why do you use those ugly underscores?!
-   </dt><dd> Because otherwise I tend to make coding mistakes surrounding
-   instance variables versus local variables. See my <a href="http://gee.cs.oswego.edu/dl/html/javaCodingStd.html"> Sample
-   Java Coding Standard</a>. But I think I've decided to reform :-)
-   Newer classes use a more JDK-like set of conventions.
-    <p>
-
-   </p></dd><dt> Why don't you supply Ant build scripts? Or Jar files?  Or
-   rearrange into separate src/doc/lib directories? Or CVS? Or ...?
-   </dt><dd> There are too many different ways people would like to use
-   this package for me to keep up with.  So I release it in a simple
-   way that should be very easy to adapt to all sorts of different
-   needs and conventions.
-   <p>
-
-   </p></dd><dt> Is this code in any way tied to Sun JDK releases?
-
-   </dt><dd> No.  The acknowlegdment to Sun Labs in headers recognizes
-   their generous donations of equipment and release time support that
-   help make this work possible. But this software is not in any way
-   tied to Sun. However, work is underway to create a JSR with the
-   goal of including a similar package in a future JDK release.
-
-    <p>
-
-   </p></dd><dt>Can I use this code in commercial products?
-   </dt><dd>Yes. Many people appear to do so.
-    <p>
-
-   </p></dd><dt>Do I need a license to use it? Can I get one?
-   </dt><dd>No!
-    <p>
-
-   </p></dd><dt>Can I get commercial support for this package?
-   </dt><dd>I don't know of any place to get it. I can't think of any
-    technical reason that you'd want it.
-    <p>
-
-  </p></dd></dl>
-
-
-<h2>Sources</h2>
-
-  <ul>
-
-    <li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Barrier.java">Barrier.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedBuffer.java">BoundedBuffer.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedChannel.java">BoundedChannel.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedLinkedQueue.java">BoundedLinkedQueue.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedPriorityQueue.java">BoundedPriorityQueue.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BrokenBarrierException.java">BrokenBarrierException.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Callable.java">Callable.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Channel.java">Channel.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ClockDaemon.java">ClockDaemon.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ConcurrentHashMap.java">ConcurrentHashMap.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ConcurrentReaderHashMap.java">ConcurrentReaderHashMap.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CondVar.java">CondVar.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.java">CopyOnWriteArrayList.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArraySet.java">CopyOnWriteArraySet.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CountDown.java">CountDown.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CyclicBarrier.java">CyclicBarrier.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/DefaultChannelCapacity.java">DefaultChannelCapacity.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/DirectExecutor.java">DirectExecutor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Executor.java">Executor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FIFOReadWriteLock.java">FIFOReadWriteLock.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FIFOSemaphore.java">FIFOSemaphore.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTask.java">FJTask.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTaskRunner.java">FJTaskRunner.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/FJTaskRunnerGroup.java">FJTaskRunnerGroup.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Heap.java">Heap.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Latch.java">Latch.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LayeredSync.java">LayeredSync.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LinkedNode.java">LinkedNode.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LinkedQueue.java">LinkedQueue.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/LockedExecutor.java">LockedExecutor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Mutex.java">Mutex.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/NullSync.java">NullSync.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ObservableSync.java">ObservableSync.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PooledExecutor.java">PooledExecutor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PrioritySemaphore.java">PrioritySemaphore.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PropertyChangeMulticaster.java">PropertyChangeMulticaster.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Puttable.java">Puttable.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/QueuedExecutor.java">QueuedExecutor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/QueuedSemaphore.java">QueuedSemaphore.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReadWriteLock.java">ReadWriteLock.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReaderPreferenceReadWriteLock.java">ReaderPreferenceReadWriteLock.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReentrantLock.java">ReentrantLock.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReentrantWriterPreferenceReadWriteLock.java">ReentrantWriterPreferenceReadWriteLock.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Rendezvous.java">Rendezvous.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Semaphore.java">Semaphore.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SemaphoreControlledChannel.java">SemaphoreControlledChannel.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Slot.java">Slot.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Sync.java">Sync.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncCollection.java">SyncCollection.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncList.java">SyncList.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncMap.java">SyncMap.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSet.java">SyncSet.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSortedMap.java">SyncSortedMap.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SyncSortedSet.java">SyncSortedSet.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedRef.java">SynchronizedRef.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedInt.java">SynchronizedInt.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedLong.java">SynchronizedLong.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedFloat.java">SynchronizedFloat.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedDouble.java">SynchronizedDouble.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedBoolean.java">SynchronizedBoolean.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedByte.java">SynchronizedByte.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedChar.java">SynchronizedChar.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedShort.java">SynchronizedShort.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronizedVariable.java">SynchronizedVariable.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/SynchronousChannel.java">SynchronousChannel.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/Takable.java">Takable.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadedExecutor.java">ThreadedExecutor.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadFactory.java">ThreadFactory.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ThreadFactoryUser.java">ThreadFactoryUser.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimedCallable.java">TimedCallable.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimeoutException.java">TimeoutException.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/TimeoutSync.java">TimeoutSync.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/VetoableChangeMulticaster.java">VetoableChangeMulticaster.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableRef.java">WaitableRef.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableInt.java">WaitableInt.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableLong.java">WaitableLong.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableFloat.java">WaitableFloat.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableDouble.java">WaitableDouble.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableBoolean.java">WaitableBoolean.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableByte.java">WaitableByte.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableChar.java">WaitableChar.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitableShort.java">WaitableShort.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaitFreeQueue.java">WaitFreeQueue.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WaiterPreferenceSemaphore.java">WaiterPreferenceSemaphore.java</a>
-    </li><li><a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/WriterPreferenceReadWriteLock.java">WriterPreferenceReadWriteLock.java</a>
-
-  </li></ul>
-
-<h2>History</h2>
-
-  <ul>
-   <li> 10Jul1998 1.0
-   </li><li> 11Jul1998 1.0.1: removed .class files from release, Fixed
-    documentation error, included Barrier interface.
-   </li><li>12Jul1998 1.0.2: Fixed return value for swap; fixed documentation errors.
-   </li><li>15Jul1998 1.0.3: Fixed more documentation errors; re-fixed swap; 
-    other cosmetic improvements.
-   </li><li>18Jul1998 1.0.4: Simplified some classes by removing
-    some alleged optimizations that do not actually help on some platforms;
-    improved SynchronizationTimer; added some documentation.
-   </li><li> 1Sep1998 version 1.1.0:
-    <ul>
-     <li>Replace SynchronousChannel algorithm with fairer, more scalable one
-     </li><li>TimeoutException now extends InterruptedException
-     </li><li>Replace int counters with longs to avoid wrapping.
-     </li><li>new LayeredSync class
-     </li><li>new ObservableSync class
-     </li><li>new NullSync class
-     </li><li>new TimeoutSync class
-     </li><li>new SyncCollection classes
-     </li><li>new ReentrantWriterPreferenceReadWriteLock class
-     </li><li>peek added to Channel
-     </li><li>new ClockDaemon class
-     </li><li>Refactorings to standardize usage of thread factories
-     </li><li>removed reliance on ThreadGroups in PooledExecutor
-    </li></ul>
-    </li><li> 7Jan 1999 Version 1.2 
-    <ul>
-     <li> ClockDaemon.shutdown allows immediate restart
-     </li><li> Callable.call throws Throwable, not Exception
-     </li><li> new Task, TaskRunner, TaskRunnerGroup classes
-     </li><li> new taskDemo subdirectory
-    </li></ul>
-   </li><li>13Jan1999 version 1.2.1
-    <ul>
-     <li>Minor cleanup of Task classes
-    </li></ul>
-
-   </li><li> 17Jan1999 version 1.2.2:
-    <ul>
-     <li> Simplify Task classes; improve documentation;
-      add priority control; they are no longer labeled as `preliminary'.
-     </li><li> More sample programs in taskDemos
-     </li><li> Add warnings about reentrancy to RW locks
-     </li><li> Callable throws Exception again, but FutureResult handles Throwables
-    </li></ul>
-
-   </li><li>25Mar1999 version 1.2.3
-    <ul>
-     <li>PooledExecutor -- allow pool to shrink when max size decreased
-     </li><li>Task -- add reset, array-based operations
-     </li><li>new PropertyChangeMulticaster, VetoableChangeMulticaster
-    </li></ul>
-
-   </li><li>21may1999 version 1.2.4
-    <ul>
-     <li>PooledExecutor -- allow supplied Channel in constructor;
-      new methods createThreads(), drain()
-     </li><li> Task, TaskRunner, TaskRunnerGroup renamed to
-         FJTask, FJTaskRunner, FJTaskRunnerGroup to avoid
-         clashes with commonly used class name of `Task'.
-     </li><li>Misc documentation improvements
-     </li><li>WriterPreferenceReadWriteLock -- fix to notify on interrupt
-    </li></ul>
-
-   </li><li>23oct1999 version 1.2.5
-    <ul>
-     <li>PooledExecutor -- add minimumPoolSize settings
-     </li><li>LU in taskDemo
-     </li><li>Minor improvements to LinkedQueue, FJTaskRunner
-    </li></ul>
-
-
-   </li><li>29dec1999 version 1.2.6
-    <ul>
-     <li>FJTaskRunner -- now works on MP JVMs that do not
-      correctly implement read-after-write of volatiles.
-     </li><li>added TimedCallable
-    </li></ul>
-
-
-   </li><li>12jan2001 version 1.3.0
-    <ul>
-     <li> new ConcurrentHashMap, ConcurrentReaderHashMap classes.
-     </li><li>BoundedLinkedQueue.setCapacity: immediately reconcile permits.
-     </li><li>ReentrantWriterPreferenceReadWriteLock: Both readers and writers
-      are now reentrant.
-     </li><li>PooledExecutor: policy now an interface, not abstract class.
-     </li><li>QueuedExecutor, PooledExecutor: new shutdown methods
-    </li></ul>
-
-   </li><li>2dec2001 Version 1.3.1
-    <ul>
-     <li> PooledExecutor: declare inner class constructor as protected,
-      more flexible shutdown support, blocked exec handlers can
-      throw InterruptedExceptions.
-     </li><li>Ensure all serialization methods are <tt>private</tt>.
-     </li><li>Joe Bowbeer's SwingWorker now in misc
-     </li><li> Improvements to ConcurrentHashMap, ConcurrentReaderHashMap,
-     FIFOReadWriteLock, ReentrantWriterPreferenceReadWriteLock.
-     WaitFreeQueue, SynchronousChannel.
-    </li></ul>
-
-   </li><li>12dec2002 Version 1.3.2
-    <ul>
-     <li> SemaphoreControlledChannel - fix constructor to
-     use longs, not ints.
-     </li><li>Improvements to Heap.
-     </li><li>Fix interference check in ConcurrentReaderHashMap.
-     </li><li> ReentrantWriterPreferenceReadWriteLock throw IllegalStateException
-      instead of NullPointerException on release errors.
-    </li></ul>
-    <li> 20feb2004 Version 1.3.3
-    <ul>
-      <li> PooledExecutor: Create new threads if needed when terminating.
-      (Thanks to Bruno Dumon), and replace dying thread if it is only one.
-      <li> Clarify by-permission wordings.
-      <li> Fix synchronization scope error in SynchronizedLong (Thanks to
-      Aaron Greenhouse.)
-    </ul>
-    <li> 20may2004 Version 1.3.4
-    <ul>
-      <li> WaitableX: notify on bitwise operations
-      <li> QueuedExecutor: can shutdown before thread created (thanks to
-      Wolfgang Hoschek)
-    </ul>
-   </li><li>Coming attractions
-    <ul>
-     <li> This package is entering maintenance mode because improved
-      versions of main functionality are part of JDK1.5 java.util.concurrent
-      via <a href="http://gee.cs.oswego.edu/dl/concurrency-interest/index.html">
-    JSR 166. </a>
-     </li>
-    </ul>
-  </li></ul>
-
-</body></html>
-  
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/overview.html
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/overview.html b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/overview.html
deleted file mode 100644
index 0172ca8..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/overview.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<HTML>
-<!-- Hints from http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html -->
-<BODY>
-JGroups is a toolkit for reliable group communication. Processes
-can join a group, send messages to all members or single members, and
-receive messages from members in the group. The system keeps track of
-the members in every group, and notifies group members when a new
-member joins, or an existing member leaves or crashes. A group is
-identified by its name. Groups do not have to be created explicitly;
-when a process joins a non-existing group, that group will be created
-automatically. Member processes of a group can be located on the same
-host, within the same LAN, or across a WAN. A member can be part of
-multiple groups. 
-</BODY>
-</HTML>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/package.html
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/package.html b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/package.html
deleted file mode 100644
index e393a0f..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/package.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<HTML>
-	<BODY>
-		Provides top-level public JGroups classes such as Channel, Message, etc.
-	</BODY>
-</HTML>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotConnectException.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotConnectException.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotConnectException.java
deleted file mode 100644
index 6cc78b2..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotConnectException.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-package  com.gemstone.org.jgroups.persistence;
-
-/**
- * @author Mandar Shinde
- * This exception inherits the Exception class and is used in
- * cases where the Persistence Storage cannot be connected to
- * for any purpose.
- */
-
-
-public class CannotConnectException extends Exception
-{
-
-    private static final long serialVersionUID = -4938856570415903498L;
-    /**
-     * @param t
-     * @param reason implementor-specified runtime reason
-     */
-    public CannotConnectException(Exception t, String reason)
-    {
-	this.t = t;
-	this.reason = reason;
-    }
-
-    /**
-     * @param t
-      * @param reason implementor-specified runtime reason
-     */
-    public CannotConnectException(Throwable t, String reason)
-    {	
-	this.t = t;
-	this.reason = reason;
-    }		
-
-    /**
-     * @return String;
-     */
-    @Override // GemStoneAddition
-    public String toString()
-    {
-	String tmp = "Exception " + t.toString() + " was thrown due to " + reason;
-	return tmp;
-    }
-
-    /**
-     * members are made available so that the top level user can dump
-     * appropriate members on to his stack trace
-     */
-    public Throwable t = null;
-    public String reason = null;
-}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotCreateSchemaException.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotCreateSchemaException.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotCreateSchemaException.java
deleted file mode 100644
index 9d40558..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotCreateSchemaException.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-package  com.gemstone.org.jgroups.persistence;
-
-/**
- * @author Mandar Shinde
- * This exception inherits the Exception class and is used in
- * cases where the Persistence Storage cannot create schema to
- * use the API as required. At this point, top level use needs to
- * decide whether to continue or abort.
- */
-
-public class CannotCreateSchemaException extends Exception
-{
-    private static final long serialVersionUID = 932964652498346597L;
-
-    /**
-     * @param t
-     * @param reason implementor-specified runtime reason
-     */
-    public CannotCreateSchemaException(Throwable t, String reason)
-    {
-	this.t = t;
-	this.reason = reason;
-    }
-
-    /**
-     * @return String
-     */
-    @Override // GemStoneAddition
-    public String toString()
-    {
-	String tmp = "Exception " + t.toString() + " was thrown due to " + reason;
-	return tmp;
-    }
-
-    /**
-     * members are made available so that the top level user can dump
-     * appropriate members on to his stack trace
-     */
-    private Throwable t = null;
-    private String reason = null;
-}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotPersistException.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotPersistException.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotPersistException.java
deleted file mode 100644
index 35ccaf5..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotPersistException.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-package  com.gemstone.org.jgroups.persistence;
-
-/**
- * @author Mandar Shinde
- * This exception inherits the Exception class and is used in
- * cases where the Persistence Storage cannot persist a pair
- * from its storage mechanism (leading to fatal errors)
- */
-
-public class CannotPersistException extends Exception
-{
-    private static final long serialVersionUID = -5346794365646061026L;
-
-    /**
-     * @param t
-     * @param reason implementor-specified runtime reason
-     */
-    public CannotPersistException(Throwable t, String reason)
-    {
-	this.t = t;
-	this.reason = reason;
-    }
-
-    /**
-     * @return String;
-     */
-    @Override // GemStoneAddition
-    public String toString()
-    {
-	String tmp = "Exception " + t.toString() + " was thrown due to " + reason;
-	return tmp;
-    }
-
-    /**
-     * members are made available so that the top level user can dump
-     * appropriate members on to his stack trace
-     */
-    private Throwable t = null;
-    private String reason = null;
-}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRemoveException.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRemoveException.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRemoveException.java
deleted file mode 100644
index e6f6fa6..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRemoveException.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-package  com.gemstone.org.jgroups.persistence;
-
-/**
- * @author Mandar Shinde
- * This exception inherits the Exception class and is used in
- * cases where the Persistence Storage cannot remove a pair
- * from its storage mechanism (leading to permannt errors)
- */
-
-public class CannotRemoveException extends Exception
-{
-
-    private static final long serialVersionUID = -11649062965054429L;
-
-    /**
-     * @param t
-     * @param reason implementor-specified runtime reason
-     */
-    public CannotRemoveException(Throwable t, String reason)
-    {
-	this.t = t;
-	this.reason = reason;
-    }
-
-    /**
-     * @return String;
-     */
-    @Override // GemStoneAddition
-    public String toString()
-    {
-	String tmp = "Exception " + t.toString() + " was thrown due to " + reason;
-	return tmp;
-    }
-
-    /**
-     * members are made available so that the top level user can dump
-     * appropriate members on to his stack trace
-     */
-    public Throwable t = null;
-    public String reason = null;
-}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/8b2ea77d/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRetrieveException.java
----------------------------------------------------------------------
diff --git a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRetrieveException.java b/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRetrieveException.java
deleted file mode 100644
index 4419fa1..0000000
--- a/gemfire-jgroups/src/main/java/com/gemstone/org/jgroups/persistence/CannotRetrieveException.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/** Notice of modification as required by the LGPL
- *  This file was modified by Gemstone Systems Inc. on
- *  $Date$
- **/
-package  com.gemstone.org.jgroups.persistence;
-
-/**
- * @author Mandar Shinde
- * This exception inherits the Exception class and is used in
- * cases where the Persistence Storage cannot retrieve a pair
- * from its storage mechanism (leading to failure of mechanism)
- */
-
-public class CannotRetrieveException extends Exception
-{
-    private static final long serialVersionUID = -3825072530525191050L;
-
-    /**
-     * @param t
-     * @param reason implementor-specified runtime reason
-     */
-    public CannotRetrieveException(Throwable t, String reason)
-    {
-	this.t = t;
-	this.reason = reason;
-    }
-
-    /**
-     * @return String;
-     */
-    @Override // GemStoneAddition
-    public String toString()
-    {
-	String tmp = "Exception " + t.toString() + " was thrown due to " + reason;
-	return tmp;
-    }
-
-    /**
-     * members are made available so that the top level user can dump
-     * appropriate members on to his stack trace
-     */
-    private Throwable t = null;
-    private String reason = null;
-}


Mime
View raw message