在 Lucene 中，如何确定 IndexSearcher 或 IndexWriter 是否正在另一个线程中使用?

Thankfully in recent versions (3.x or late 2.x) they added a method to tell you if there has been any writing after the searcher had been opened. IndexReader.isCurrent() will tell you if any changes have occurred since this reader was open or not. So you probably will create a simple wrapper class that encapsulates both reading and writing, and with some simple synchronization you can provide 1 class that manages all of this between all of the threads.

这大概是我的工作:

  public class ArchiveIndex {
      private IndexSearcher search;
      private AtomicInteger activeSearches = new AtomicInteger(0);
      private IndexWriter writer;
      private AtomicInteger activeWrites = new AtomicInteger(0);

      public List<Document> search( ... ) {
          synchronized( this ) {
              if( search != null && !search.getIndexReader().isCurrent() && activeSearches.get() == 0 ) {
                 searcher.close();
                 searcher = null;
              }

              if( search == null ) {
                  searcher = new IndexSearcher(...);
              }
          }

          activeSearches.increment();
          try {
              // do you searching
          } finally {
              activeSearches.decrement();
          }
          // do you searching
      }


      public void addDocuments( List<Document> docs ) {
          synchronized( this ) {
             if( writer == null ) {
                 writer = new IndexWriter(...);
             }
          }
          try {
              activeWrites.incrementAndGet();
              // do you writes here.
          } finally {
              synchronized( this ) {
                  int writers = activeWrites.decrementAndGet();
                  if( writers == 0 ) {
                      writer.close();
                      writer = null;
                  }
              }
          }
      }
  }

所以我有一个课程可供读者和作者使用.注意这个类允许同时写和读，多个读者可以同时搜索.唯一的同步是快速检查是否需要重新打开搜索器/编写器.我没有在方法级别上进行同步，这一次只允许一个读取器/写入器，这在性能方面会很糟糕.如果那里有活跃的搜索者，则不能删除搜索者.因此，如果您有很多读者进来，只需简单地搜索而不进行更改.一旦它缩小，下一个单独的搜索器将重新打开脏搜索器.这对于流量会暂停的低流量站点可能非常有用.它仍然可能导致饥饿(即您总是在阅读越来越旧的结果).您可以添加逻辑来简单地停止并重新初始化，如果自从它被注意到脏的时间比 X 更早，否则我们就像现在一样懒惰.这样你就可以保证搜索永远不会早于 X.