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,65 @@
     // 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) {
+        if (mv.reader != null) {
+          mv.reader.incRef();
+          return mv.reader;
+        }
       }
-      return sr;
+      return null;
     }
   }
   
+  static final class SRMapValue {
+    SegmentReader reader;
+  }
+  
   synchronized void acquireWrite() {
     assert writeThread != Thread.currentThread();
     while(writeThread != null || readCount > 0)
Index: src/test/org/apache/lucene/index/Test1726.java
===================================================================
--- src/test/org/apache/lucene/index/Test1726.java	(revision 0)
+++ src/test/org/apache/lucene/index/Test1726.java	(revision 0)
@@ -0,0 +1,93 @@
+package org.apache.lucene.index;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.lucene.analysis.WhitespaceAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.TestIndexWriterReader.HeavyAtomicInt;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.MockRAMDirectory;
+import org.apache.lucene.util.LuceneTestCase;
+
+public class Test1726 extends LuceneTestCase {
+  Random random = new Random();
+  HeavyAtomicInt seq = new HeavyAtomicInt(1);
+  List readerList = new ArrayList();
+
+  public void testIndexing() throws Exception {
+    Directory mainDir = new MockRAMDirectory();
+    IndexWriter writer = new IndexWriter(mainDir, new WhitespaceAnalyzer(),
+        IndexWriter.MaxFieldLength.LIMITED);
+    writer.setMergeFactor(2);
+    writer.setMaxBufferedDocs(10);
+    RunThread[] indexThreads = new RunThread[4];
+    for (int x=0; x < indexThreads.length; x++) {
+      indexThreads[x] = new RunThread(writer);
+      indexThreads[x].start();
+    }    
+    long startTime = System.currentTimeMillis();
+    long duration = 5*60*1000;
+    while (true) {
+      boolean b= (System.currentTimeMillis() - startTime) > duration;
+      Thread.sleep(100);
+      if (b) break;
+    }
+    int delCount = 0;
+    int addCount = 0;
+    for (int x=0; x < indexThreads.length; x++) {
+      indexThreads[x].run = false;
+      assertTrue(indexThreads[x].ex == null);
+      addCount += indexThreads[x].addCount;
+      delCount += indexThreads[x].delCount;
+    }
+    for (int x=0; x < indexThreads.length; x++) {
+      indexThreads[x].join();
+    }
+    System.out.println("addCount:"+addCount);
+    System.out.println("delCount:"+delCount);
+    writer.close();
+    mainDir.close();
+  }
+
+  public class RunThread extends Thread {
+    IndexWriter writer;
+    boolean run = true;
+    Throwable ex;
+    int delCount = 0;
+    int addCount = 0;
+
+    public RunThread(IndexWriter writer) {
+      this.writer = writer;
+    }
+
+    public void run() {
+      try {
+        while (run) {
+          int n = random.nextInt(2);
+          if (n == 0) {
+            int i = seq.addAndGet(1);
+            Document doc = TestIndexWriterReader.createDocument(i, "index1", 5);
+            writer.addDocument(doc);
+            addCount++;
+          } else if (n == 1) {
+            // we may or may not delete, however we're
+            // opening a new reader and closing it rapidly
+            IndexReader reader = writer.getReader();
+            int id = random.nextInt(seq.intValue());
+            Term term = new Term("id", Integer.toString(id));
+            int count = TestIndexWriterReader.count(term, reader);
+            writer.deleteDocuments(term);
+            reader.close();
+            delCount += count;
+          }
+        }
+      } catch (Throwable ex) {
+        ex.printStackTrace(System.out);
+        this.ex = ex;
+        run = false;
+      }
+    }
+  }
+}
Index: src/test/org/apache/lucene/index/TestIndexWriterReader.java
===================================================================
--- src/test/org/apache/lucene/index/TestIndexWriterReader.java	(revision 791560)
+++ src/test/org/apache/lucene/index/TestIndexWriterReader.java	(working copy)
@@ -42,7 +42,7 @@
 public class TestIndexWriterReader extends LuceneTestCase {
   static PrintStream infoStream;
 
-  private static class HeavyAtomicInt {
+  public static class HeavyAtomicInt {
     private int value;
     public HeavyAtomicInt(int start) {
       value = start;