Index: CHANGES.txt
===================================================================
--- CHANGES.txt	(revision 778176)
+++ CHANGES.txt	(working copy)
@@ -321,6 +321,8 @@
 26. LUCENE-1550: Added new n-gram based String distance measure for spell checking.
     See the Javadocs for NGramDistance.java for a reference paper on why this is helpful (Tom Morton via Grant Ingersoll)
         
+27. LUCENE-1658: Absorb NIOFSDirectory into FSDirectory, adding a
+    useNIO setting to FSDirectory.  (Michael McCandless)
     
 Optimizations
 
Index: src/test/org/apache/lucene/store/TestDirectory.java
===================================================================
--- src/test/org/apache/lucene/store/TestDirectory.java	(revision 778176)
+++ src/test/org/apache/lucene/store/TestDirectory.java	(working copy)
@@ -53,8 +53,8 @@
     int sz = 3;
     Directory[] dirs = new Directory[sz];
 
-    dirs[0] = new FSDirectory(path, null);
-    dirs[1] = new NIOFSDirectory(path, null);
+    dirs[0] = new FSDirectory(path, null, false);
+    dirs[1] = new FSDirectory(path, null, true);
     dirs[2] = new MMapDirectory(path, null);
 
     for (int i=0; i<sz; i++) {
Index: src/java/org/apache/lucene/store/NIOFSDirectory.java
===================================================================
--- src/java/org/apache/lucene/store/NIOFSDirectory.java	(revision 778176)
+++ src/java/org/apache/lucene/store/NIOFSDirectory.java	(working copy)
@@ -39,6 +39,7 @@
  * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6265734 
  * 
  * @see FSDirectory
+ * @deprecated Use FSDirectory with useNIO enabled, instead.
  */
 
 public class NIOFSDirectory extends FSDirectory {
Index: src/java/org/apache/lucene/store/FSDirectory.java
===================================================================
--- src/java/org/apache/lucene/store/FSDirectory.java	(revision 778176)
+++ src/java/org/apache/lucene/store/FSDirectory.java	(working copy)
@@ -23,6 +23,8 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.HashMap;
@@ -32,6 +34,7 @@
 
 // Used only for WRITE_LOCK_NAME in deprecated create=true case:
 import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.util.Constants;
 
 /**
  * Straightforward implementation of {@link Directory} as a directory of files.
@@ -53,6 +56,7 @@
    * instance for a given canonical path is closed, we remove the
    * instance from the cache.  See LUCENE-776
    * for some relevant discussion.
+   * @deprecated -- we have deprecated all places that use this
    */
   private static final Map DIRECTORIES = new HashMap();
 
@@ -270,21 +274,56 @@
     }
   }
 
+  /* We default nio to true on all plaforms but Windows,
+   * because of a bug in how FileChannel.read is implemented
+   * in Sun's JRE.  Inside of the implementation the
+   * position is apparently synchronized.  See here for
+   * details:
+   * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6265734 
+   */
+  private static final boolean DEFAULT_USE_NIO = !Constants.WINDOWS;
+
   private File directory = null;
   private int refCount;
+  private final boolean useNIO;
 
-  protected FSDirectory() {};                     // permit subclassing
+  // permit subclassing
+  protected FSDirectory() {
+    useNIO = DEFAULT_USE_NIO;
+  }
 
-  /** Create a new FSDirectory for the named location.
+  /** Create a new FSDirectory for the named location.  By
+   *  default, useNIO will be true on all platforms but
+   *  Windows.  See {@link #FSDirectory(File, LockFactory,
+   *  boolean)} for details.
    *
    * @param path the path of the directory
    * @param lockFactory the lock factory to use, or null for the default.
    * @throws IOException
    */
   public FSDirectory(File path, LockFactory lockFactory) throws IOException {
+    this(path, lockFactory, DEFAULT_USE_NIO);
+  }
+
+  /** Create a new FSDirectory for the named location, with
+   *  control over whether java.nio.* is used.
+   *
+   *  <p>If useNIO is true, java.nio.* is used.  This gives
+   *  sizable gain in concurrent performance (when multiple
+   *  threads are searching).  Unfortuntely, on Windows it
+   *  gives worse performance due to a known bug in Sun's
+   *  JRE (http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6265734).
+   *
+   * @param path the path of the directory
+   * @param lockFactory the lock factory to use, or null for the default.
+   * @param useNIO true if java.nio.* should be used
+   * @throws IOException
+   */
+  public FSDirectory(File path, LockFactory lockFactory, boolean useNIO) throws IOException {
     path = getCanonicalPath(path);
     init(path, lockFactory);
     refCount = 1;
+    this.useNIO = useNIO;
   }
 
   private void init(File path, LockFactory lockFactory) throws IOException {
@@ -559,7 +598,11 @@
   // Inherit javadoc
   public IndexInput openInput(String name, int bufferSize) throws IOException {
     ensureOpen();
-    return new FSIndexInput(new File(directory, name), bufferSize);
+    if (useNIO) {
+      return new NIOFSIndexInput(new File(directory, name), bufferSize);
+    } else {
+      return new FSIndexInput(new File(directory, name), bufferSize);
+    }
   }
 
   /**
@@ -702,6 +745,76 @@
     }
   }
 
+  // Used when useNIO is enabled
+  protected static class NIOFSIndexInput extends FSIndexInput {
+
+    private ByteBuffer byteBuf; // wraps the buffer for NIO
+
+    private byte[] otherBuffer;
+    private ByteBuffer otherByteBuf;
+
+    final FileChannel channel;
+
+    public NIOFSIndexInput(File path, int bufferSize) throws IOException {
+      super(path, bufferSize);
+      channel = file.getChannel();
+    }
+
+    protected void newBuffer(byte[] newBuffer) {
+      super.newBuffer(newBuffer);
+      byteBuf = ByteBuffer.wrap(newBuffer);
+    }
+
+    public void close() throws IOException {
+      if (!isClone && file.isOpen) {
+        // Close the channel & file
+        try {
+          channel.close();
+        } finally {
+          file.close();
+        }
+      }
+    }
+
+    protected void readInternal(byte[] b, int offset, int len) throws IOException {
+
+      final ByteBuffer bb;
+
+      // Determine the ByteBuffer we should use
+      if (b == buffer && 0 == offset) {
+        // Use our own pre-wrapped byteBuf:
+        assert byteBuf != null;
+        byteBuf.clear();
+        byteBuf.limit(len);
+        bb = byteBuf;
+      } else {
+        if (offset == 0) {
+          if (otherBuffer != b) {
+            // Now wrap this other buffer; with compound
+            // file, we are repeatedly called with its
+            // buffer, so we wrap it once and then re-use it
+            // on subsequent calls
+            otherBuffer = b;
+            otherByteBuf = ByteBuffer.wrap(b);
+          } else
+            otherByteBuf.clear();
+          otherByteBuf.limit(len);
+          bb = otherByteBuf;
+        } else
+          // Always wrap when offset != 0
+          bb = ByteBuffer.wrap(b, offset, len);
+      }
+
+      long pos = getFilePointer();
+      while (bb.hasRemaining()) {
+        int i = channel.read(bb, pos);
+        if (i == -1)
+          throw new IOException("read past EOF");
+        pos += i;
+      }
+    }
+  }
+
   protected static class FSIndexOutput extends BufferedIndexOutput {
     RandomAccessFile file = null;