我们有一个程序，它持续运行，做各种事情，并更改我们数据库中的一些记录。这些记录使用 Lucene 编制索引。所以每次我们改变一个实体时，我们都会做类似的事情:

1. 打开数据库事务，打开Lucene IndexWriter
2. 在事务中对数据库进行更改，并使用 indexWriter.deleteDocuments(..) 然后 indexWriter.addDocument(..) 在 Lucene 中更新该实体.
3. 如果一切顺利，提交数据库事务并提交 IndexWriter。

这工作正常，但随着时间的推移，indexWriter.commit() 需要越来越多的时间。最初它需要大约 0.5 秒，但经过数百次此类交易后，它需要超过 3 秒。如果脚本运行时间更长，我相信它会花费更长的时间。

到目前为止，我的解决方案是注释掉 indexWriter.addDocument(..) 和 indexWriter.commit()，并时不时地重新创建整个索引首先使用 indexWriter.deleteAll() 然后在一个 Lucene transction/IndexWriter 中重新添加所有文档(约 14 秒内约 250k 个文档)。但这显然违背了数据库和 Lucene 提供的事务性方法，后者使两者保持同步，并使使用 Lucene 进行搜索的我们工具的用户可以看到数据库的更新。

我14秒可以添加250k个文档，但是添加1个文档需要3秒，这似乎很奇怪。我做错了什么，我该如何改善这种情况？

最佳答案

你做错的是假设 Lucene 的 built-in transactional capabilities具有与典型关系数据库相当的性能和保证，当they really don't .更具体地说，在您的情况下，提交会将所有索引文件与磁盘同步，从而使提交时间与索引大小成正比。这就是为什么随着时间的推移您的 indexWriter.commit() 需要越来越多的时间。 Javadoc IndexWriter.commit() 甚至警告说:

This may be a costly operation, so you should test the cost in your application and do it only when really necessary.

您能想象数据库文档会告诉您避免提交吗？

由于您的主要目标似乎是通过 Lucene 搜索及时保持数据库更新可见，为了改善这种情况，请执行以下操作:

1. 让 indexWriter.deleteDocuments(..) 和 indexWriter.addDocument(..) 在数据库提交成功之后触发，而不是之前
2. 定期执行 indexWriter.commit() 而不是每次事务，只是为了确保您的更改最终写入磁盘
3. 使用 SearcherManager用于搜索和调用 maybeRefresh()在合理的时间范围内定期查看更新的文档

下面是一个示例程序，演示了如何通过定期执行 maybeRefresh() 来检索文档更新。它建立了 100000 个文档的索引，使用 ScheduledExecutorService设置 commit() 和 maybeRefresh() 的定期调用，提示您更新单个文档，然后重复搜索直到更新可见。程序终止时会正确清理所有资源。请注意，更新何时可见的控制因素是何时调用 maybeRefresh()，而不是 commit()。

import java.io.IOException;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.concurrent.*;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import org.apache.lucene.search.*;
import org.apache.lucene.store.FSDirectory;

public class LucenePeriodicCommitRefreshExample {
    ScheduledExecutorService scheduledExecutor;
    MyIndexer indexer;
    MySearcher searcher;

    void init() throws IOException {
        scheduledExecutor = Executors.newScheduledThreadPool(3);
        indexer = new MyIndexer();
        indexer.init();
        searcher = new MySearcher(indexer.indexWriter);
        searcher.init();
    }

    void destroy() throws IOException {
        searcher.destroy();
        indexer.destroy();
        scheduledExecutor.shutdown();
    }

    class MyIndexer {
        IndexWriter indexWriter;
        Future commitFuture;

        void init() throws IOException {
            indexWriter = new IndexWriter(FSDirectory.open(Paths.get("C:\\Temp\\lucene-example")), new IndexWriterConfig(new StandardAnalyzer()));
            indexWriter.deleteAll();
            for (int i = 1; i <= 100000; i++) {
                add(String.valueOf(i), "whatever " + i);
            }
            indexWriter.commit();
            commitFuture = scheduledExecutor.scheduleWithFixedDelay(() -> {
                try {
                    indexWriter.commit();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }, 5, 5, TimeUnit.MINUTES);
        }

        void add(String id, String text) throws IOException {
            Document doc = new Document();
            doc.add(new StringField("id", id, Field.Store.YES));
            doc.add(new StringField("text", text, Field.Store.YES));
            indexWriter.addDocument(doc);
        }

        void update(String id, String text) throws IOException {
            indexWriter.deleteDocuments(new Term("id", id));
            add(id, text);
        }

        void destroy() throws IOException {
            commitFuture.cancel(false);
            indexWriter.close();
        }
    }

    class MySearcher {
        IndexWriter indexWriter;
        SearcherManager searcherManager;
        Future maybeRefreshFuture;

        public MySearcher(IndexWriter indexWriter) {
            this.indexWriter = indexWriter;
        }

        void init() throws IOException {
            searcherManager = new SearcherManager(indexWriter, true, null);
            maybeRefreshFuture = scheduledExecutor.scheduleWithFixedDelay(() -> {
                try {
                    searcherManager.maybeRefresh();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }, 0, 5, TimeUnit.SECONDS);
        }

        String findText(String id) throws IOException {
            IndexSearcher searcher = null;
            try {
                searcher = searcherManager.acquire();
                TopDocs topDocs = searcher.search(new TermQuery(new Term("id", id)), 1);
                return searcher.doc(topDocs.scoreDocs[0].doc).getField("text").stringValue();
            } finally {
                if (searcher != null) {
                    searcherManager.release(searcher);
                }
            }
        }

        void destroy() throws IOException {
            maybeRefreshFuture.cancel(false);
            searcherManager.close();
        }
    }

    public static void main(String[] args) throws IOException {
        LucenePeriodicCommitRefreshExample example = new LucenePeriodicCommitRefreshExample();
        example.init();
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                try {
                    example.destroy();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        try (Scanner scanner = new Scanner(System.in)) {
            System.out.print("Enter a document id to update (from 1 to 100000): ");
            String id = scanner.nextLine();
            System.out.print("Enter what you want the document text to be: ");
            String text = scanner.nextLine();
            example.indexer.update(id, text);
            long startTime = System.nanoTime();
            String foundText;
            do {
                foundText = example.searcher.findText(id);
            } while (!text.equals(foundText));
            long elapsedTimeMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
            System.out.format("it took %d milliseconds for the searcher to see that document %s is now '%s'\n", elapsedTimeMillis, id, text);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.exit(0);
        }
    }
}

此示例已成功使用 Lucene 5.3.1 和 JDK 1.8.0_66 进行测试。

关于java - 写入 Lucene 索引，一次一个文档，随着时间的推移变慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32269632/