Index: src/java/org/apache/lucene/index/IndexWriter.java
===================================================================
--- src/java/org/apache/lucene/index/IndexWriter.java	(revision 791560)
+++ src/java/org/apache/lucene/index/IndexWriter.java	(working copy)
@@ -462,16 +462,26 @@
         Iterator iter = readerMap.entrySet().iterator();
         while (iter.hasNext()) {
           Map.Entry ent = (Map.Entry) iter.next();
-          ((SegmentReader) ent.getValue()).hasChanges = false;
+          SRMapValue mv = (SRMapValue)ent.getValue();
+          synchronized (mv) {
+            if (mv.reader != null) {
+              mv.reader.hasChanges = false;
+            }
+          }
         }
       } else {
         final int numSegments = infos.size();
         for(int i=0;i<numSegments;i++) {
           final SegmentInfo info = infos.info(i);
           if (readerMap.containsKey(info)) {
-            ((SegmentReader) readerMap.get(info)).hasChanges = false;
+            SRMapValue mv = (SRMapValue)readerMap.get(info);
+            synchronized (mv) {
+              if (mv.reader != null) {
+                mv.reader.hasChanges = false;
+              }
+            }
           }
-        }     
+        }
       }
     }
     
@@ -498,35 +508,37 @@
     synchronized void release(SegmentReader sr, boolean drop) throws IOException {
 
       final boolean pooled = readerMap.containsKey(sr.getSegmentInfo());
+      SRMapValue mv = (SRMapValue)readerMap.get(sr.getSegmentInfo());
+      synchronized (mv) {
+        assert !pooled | mv.reader == sr;
 
-      assert !pooled | readerMap.get(sr.getSegmentInfo()) == sr;
+        // Drop caller's ref
+        sr.decRef();
 
-      // Drop caller's ref
-      sr.decRef();
+        if (pooled && (drop || (!poolReaders && sr.getRefCount() == 1))) {
 
-      if (pooled && (drop || (!poolReaders && sr.getRefCount() == 1))) {
+          // We are the last ref to this reader; since we're
+          // not pooling readers, we release it:
+          readerMap.remove(sr.getSegmentInfo());
 
-        // We are the last ref to this reader; since we're
-        // not pooling readers, we release it:
-        readerMap.remove(sr.getSegmentInfo());
+          // TODO: java 5
+          // assert !sr.hasChanges || Thread.holdsLock(IndexWriter.this);
 
-        // TODO: java 5
-        // assert !sr.hasChanges || Thread.holdsLock(IndexWriter.this);
-
-        // Drop our ref -- this will commit any pending
-        // changes to the dir
-        boolean success = false;
-        try {
-          sr.close();
-          success = true;
-        } finally {
-          if (!success && sr.hasChanges) {
-            // Abandon the changes & retry closing:
-            sr.hasChanges = false;
-            try {
-              sr.close();
-            } catch (Throwable ignore) {
-              // Keep throwing original exception
+          // Drop our ref -- this will commit any pending
+          // changes to the dir
+          boolean success = false;
+          try {
+            sr.close();
+            success = true;
+          } finally {
+            if (!success && sr.hasChanges) {
+              // Abandon the changes & retry closing:
+              sr.hasChanges = false;
+              try {
+                sr.close();
+              } catch (Throwable ignore) {
+                // Keep throwing original exception
+              }
             }
           }
         }
@@ -539,48 +551,53 @@
       Iterator iter = readerMap.entrySet().iterator();
       while (iter.hasNext()) {
         Map.Entry ent = (Map.Entry) iter.next();
-
-        SegmentReader sr = (SegmentReader) ent.getValue();
-        if (sr.hasChanges) {
-          assert infoIsLive(sr.getSegmentInfo());
-          sr.startCommit();
-          boolean success = false;
-          try {
-            sr.doCommit(null);
-            success = true;
-          } finally {
-            if (!success) {
-              sr.rollbackCommit();
+        SRMapValue mv = (SRMapValue)ent.getValue();
+        synchronized (mv) {
+          SegmentReader sr = mv.reader;
+          if (sr.hasChanges) {
+            assert infoIsLive(sr.getSegmentInfo());
+            sr.startCommit();
+            boolean success = false;
+            try {
+              sr.doCommit(null);
+              success = true;
+            } finally {
+              if (!success) {
+                sr.rollbackCommit();
+              }
             }
           }
+          iter.remove();
+
+          // NOTE: it is allowed that this decRef does not
+          // actually close the SR; this can happen when a
+          // near real-time reader is kept open after the
+          // IndexWriter instance is closed
+          sr.decRef();
         }
-
-        iter.remove();
-
-        // NOTE: it is allowed that this decRef does not
-        // actually close the SR; this can happen when a
-        // near real-time reader is kept open after the
-        // IndexWriter instance is closed
-        sr.decRef();
       }
     }
     
+    // TODO: make a copy of the map and commit unsynchronized
     public synchronized void commit() throws IOException {
       Iterator iter = readerMap.entrySet().iterator();
       while (iter.hasNext()) {
         Map.Entry ent = (Map.Entry) iter.next();
 
-        SegmentReader sr = (SegmentReader) ent.getValue();
-        if (sr.hasChanges) {
-          assert infoIsLive(sr.getSegmentInfo());
-          sr.startCommit();
-          boolean success = false;
-          try {
-            sr.doCommit(null);
-            success = true;
-          } finally {
-            if (!success) {
-              sr.rollbackCommit();
+        SRMapValue mv = (SRMapValue)ent.getValue();
+        synchronized (mv) {
+          SegmentReader sr = mv.reader;
+          if (sr != null && sr.hasChanges) {
+            assert infoIsLive(sr.getSegmentInfo());
+            sr.startCommit();
+            boolean success = false;
+            try {
+              sr.doCommit(null);
+              success = true;
+            } finally {
+              if (!success) {
+                sr.rollbackCommit();
+              }
             }
           }
         }
@@ -590,52 +607,67 @@
     // Returns a ref to a clone.  NOTE: this clone is not
     // enrolled in the pool, so you should simply close()
     // it when you're done (ie, do not call release()).
-    public synchronized SegmentReader getReadOnlyClone(SegmentInfo info, boolean doOpenStores) throws IOException {
+    public SegmentReader getReadOnlyClone(SegmentInfo info, boolean doOpenStores) throws IOException {
       SegmentReader sr = get(info, doOpenStores);
-      try {
-        return (SegmentReader) sr.clone(true);
-      } finally {
-        sr.decRef();
+      synchronized (this) {
+        try {
+          return (SegmentReader) sr.clone(true);
+        } finally {
+          sr.decRef();
+        }
       }
     }
    
     // Returns a ref
-    public synchronized SegmentReader get(SegmentInfo info, boolean doOpenStores) throws IOException {
+    public SegmentReader get(SegmentInfo info, boolean doOpenStores) throws IOException {
       return get(info, doOpenStores, BufferedIndexInput.BUFFER_SIZE);
     }
+    
+    public SegmentReader get(SegmentInfo info, boolean doOpenStores, int readBufferSize) throws IOException {
 
-    public synchronized SegmentReader get(SegmentInfo info, boolean doOpenStores, int readBufferSize) throws IOException {
-
       if (poolReaders) {
         readBufferSize = BufferedIndexInput.BUFFER_SIZE;
       }
-
-      SegmentReader sr = (SegmentReader) readerMap.get(info);
-      if (sr == null) {
-        // TODO: we may want to avoid doing this while
-        // synchronized
-        // Returns a ref, which we xfer to readerMap:
-        sr = SegmentReader.get(info, readBufferSize, doOpenStores);
-        readerMap.put(info, sr);
-      } else if (doOpenStores) {
-        sr.openDocStores();
+      SRMapValue mv = null;
+      // synchronize on the readerPool access to the readerMap
+      synchronized (this) {
+        mv = (SRMapValue)readerMap.get(info);
+        if (mv == null) {
+          mv = new SRMapValue();
+          readerMap.put(info, mv);
+        }
       }
-
-      // Return a ref to our caller
-      sr.incRef();
-      return sr;
+      synchronized (mv) {
+        if (mv.reader == null) {
+          mv.reader = SegmentReader.get(info, readBufferSize, doOpenStores);
+        }
+        // Return a ref to our caller
+        mv.reader.incRef();
+        if (doOpenStores) mv.reader.openDocStores();
+      }
+      return mv.reader;
     }
 
     // Returns a ref
     public synchronized SegmentReader getIfExists(SegmentInfo info) throws IOException {
-      SegmentReader sr = (SegmentReader) readerMap.get(info);
-      if (sr != null) {
-        sr.incRef();
+      SRMapValue mv = (SRMapValue)readerMap.get(info);
+      if (mv == null) return null;
+      synchronized (mv) {
+        SegmentReader sr = null;
+        if (mv.reader != null) {
+          sr = mv.reader;
+          sr.incRef();
+          return sr;
+        }
       }
-      return sr;
+      return null;
     }
   }
   
+  static final class SRMapValue {
+    SegmentReader reader;
+  }
+  
   synchronized void acquireWrite() {
     assert writeThread != Thread.currentThread();
     while(writeThread != null || readCount > 0)