diff --git a/lucene/core/src/java/org/apache/lucene/search/ReferenceManager.java b/lucene/core/src/java/org/apache/lucene/search/ReferenceManager.java
index a663914..4708494 100755
--- a/lucene/core/src/java/org/apache/lucene/search/ReferenceManager.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ReferenceManager.java
@@ -88,12 +88,28 @@ public abstract class ReferenceManager<G> implements Closeable {
     } while (!tryIncRef(ref));
     return ref;
   }
-
+  
   /**
-   * Close this ReferenceManager to future {@link #acquire() acquiring}. Any
-   * references that were previously {@link #acquire() acquired} won't be
-   * affected, and they should still be {@link #release released} when they are
-   * not needed anymore.
+   * <p>
+   * Close this ReferenceManager to future {@link #acquire() acquiring}. A
+   * reference manager should be closed if the reference to the managed resource
+   * should be disposed or if applications using the {@link ReferenceManager}
+   * are shutting down. The managed resource might not be released immediately,
+   * if the {@link ReferenceManager} user is holding on to a previously
+   * {@link #acquire() acquired} reference the resource will be released once
+   * the the last reference is {@link #release(Object) released}. Those
+   * references can still be used as if the manager was still active.
+   * </p>
+   * <p>
+   * Applications should not {@link #acquire() acquired} references from this
+   * manager once this method was called. {@link #acquire() acquiring} a
+   * resource on a closed {@link ReferenceManager} will throw an
+   * {@link AlreadyClosedException}.
+   * </p>
+   * 
+   * @throws IOException
+   *           iff decrementing the current reference count causes an
+   *           {@link IOException}
    */
   public final synchronized void close() throws IOException {
     if (current != null) {
@@ -158,6 +174,8 @@ public abstract class ReferenceManager<G> implements Closeable {
    * If this method returns true it means the calling thread either refreshed or
    * that there were no changes to refresh. If it returns false it means another
    * thread is currently refreshing.
+   * </p>
+   * @throws IOException if refreshing the resource causes an {@link IOException}
    */
   public final boolean maybeRefresh() throws IOException {
     ensureOpen();
@@ -185,6 +203,7 @@ public abstract class ReferenceManager<G> implements Closeable {
    * useful if you want to guarantee that the next call to {@link #acquire()}
    * will return a refreshed instance. Otherwise, consider using the
    * non-blocking {@link #maybeRefresh()}.
+   * @throws IOException if refreshing the resource causes an {@link IOException}
    */
   public final void maybeRefreshBlocking() throws IOException {
     ensureOpen();
@@ -199,7 +218,9 @@ public abstract class ReferenceManager<G> implements Closeable {
   }
 
   /** Called after swapReference has installed a new
-   *  instance. */
+   *  instance.
+   *  @throws IOException if a low level I/O exception occurs  
+   **/
   protected void afterRefresh() throws IOException {
   }