Lucene 4.4.0新Controlled RealtimeRestore线程示例用法

在Lucene的新4.4.0版本中，近实时管理器（org.apache.Lucene.search.NRTManage）已被替换为

有没有人有一些新ControlleDrealtimeRecoverThread使用的示例代码

---

编辑：我在下面回答我自己的问题

我对这个问题做了一些研究，并建立了一个实用类型。。。没有经过充分的测试（特别是在并发条件下），无论如何它都可以工作，而且我非常确定它是线程安全的

@Slf4j
公共类LuceneIndex{
私人最终索引编写器(IndexWriter);；
私人最终跟踪索引编写器\u跟踪索引编写器；
私人最终参考管理器(索引搜索器参考管理器),；
private final ControlledRealTimeRestoreThread_IndexSearcherRestoreThread；
private long _rebootToken；//索引更新/删除方法返回标记
//////////建造商和定稿
/**
*基于负责lucene索引持久性的类型的实例的构造函数
*/
@注入
公共LuceneIndex（最终目录luceneDirectory，
最终分析仪（分析仪）{
试一试{
//[1]：创建indexWriter
_indexWriter=新的indexWriter（Lucene目录，
新的IndexWriterConfig（LuceneConstants.VERSION，
分析仪）；
//[2a]：创建TrackingIndexWriter以跟踪对先前创建的委托IndexWriter的更改
_trackingIndexWriter=新的trackingIndexWriter（_indexWriter）；
//[2b]：创建一个IndexSearcher引用管理器，以便跨多个应用程序安全地共享IndexSearcher实例
//多线程
_indexSearcherReferenceManager=新的SearcherManager（_indexWriter，
是的，
无效）；
//[3]：创建ControlledRealTimeRebootThread，该线程将定期重新打开索引
//说明对索引所做的更改，并由TrackingIndexWriter实例跟踪
//无人等待时，索引每60秒刷新一次
//每当有人等待时，每100毫秒一次（参见搜索方法）
//（见http://lucene.apache.org/core/4_3_0/core/org/apache/lucene/search/NRTManagerReopenThread.html)
_IndexSearcherRebootThread=新的ControlledRealtimeRebootThread（\u trackingIndexWriter，
_indexSearcherReferenceManager，
60.00，//当无人等待时
0.1）；//当有人在等待时
_IndexSearcherRestoreThread.start（）；//启动刷新线程
}捕获（IOException ioEx）{
抛出新的IllegalStateException（“无法创建Lucene索引：”+ioEx.getMessage（））；
}
}
@凌驾
受保护的void finalize（）抛出可丢弃的{
这个。关闭（）；
super.finalize（）；
}
/**
*关闭每个索引
*/
公众假期结束（）{
试一试{
//停止索引读取器，重新打开线程
_IndexSearcherThread.interrupt（）；
_IndexSearcherThread.close（）；
//关闭indexWriter，提交所有待处理的内容
_indexWriter.commit（）；
_indexWriter.close（）；
}捕获（IOException ioEx）{
log.error（“关闭lucene索引时出错：{}”，ioEx.getMessage（），
ioEx）；
}
}
//////////索引
/**
*索引Lucene文档
*@param doc要编制索引的文档
*/
公开作废索引（最终文件文件）{
试一试{
_rebootToken=\u trackingIndexWriter.addDocument（doc）；
debug（“在lucene中索引的文档”）；
}捕获（IOException ioEx）{
log.error（“在Lucene索引操作中出错：{}”，ioEx.getMessage（），
ioEx）；
}最后{
试一试{
_indexWriter.commit（）；
}捕获（IOException ioEx）{
log.error（“提交对Lucene索引的更改时出错：{}”，ioEx.getMessage（），
ioEx）；
}
}
}
/**
*更新lucene文档的索引信息
*@param doc要编制索引的文档
*/
公共无效重新索引（最终期限记录期限，
最后文件{
试一试{
_RebootToken=\u trackingIndexWriter.updateDocument（recordIdTerm，
doc）；
log.debug（“{}文档在lucene中重新索引”，recordIdTerm.text（））；
}捕获（IOException ioEx）{
log.error（“lucene重新索引操作中的错误：{}”，ioEx.getMessage（），
ioEx）；
}最后{
试一试{
_indexWriter.commit（）；
}捕获（IOException ioEx）{
log.error（“提交对Lucene索引的更改时出错：{}”，ioEx.getMessage（），
ioEx）；
}
}
}
/**
*取消lucene文档的索引
*@param idTerm用于定位要取消索引的文档
*重要提示！术语必须仅过滤文档，且仅过滤文档
*否则，所有匹配的文档都将被取消编码
package kr.nsri.lucene440;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.index.TrackingIndexWriter;
import org.apache.lucene.search.ControlledRealTimeReopenThread;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ReferenceManager;
import org.apache.lucene.search.SearcherManager;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

public class AddRandom {

    public static void main(String[] args) throws IOException,
            InterruptedException {

        // Basic Environment
        FSDirectory dir = FSDirectory
                .open(new File("/Users/inseog/tmp/lu440/"));
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_44);
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(
                Version.LUCENE_44, analyzer);
        indexWriterConfig.setOpenMode(OpenMode.CREATE_OR_APPEND);
        IndexWriter indexWriter = new IndexWriter(dir, indexWriterConfig);

        // Real time handler
        TrackingIndexWriter trackingIndexWriter = new TrackingIndexWriter(
                indexWriter);
        ReferenceManager<IndexSearcher> searcherManager = new SearcherManager(
                indexWriter, false, null);

        // thread handling
        ControlledRealTimeReopenThread<IndexSearcher> writeControlThread = new ControlledRealTimeReopenThread<IndexSearcher>(
                trackingIndexWriter, searcherManager, 1.0, 0.1);
        writeControlThread.setName("Update Reopen Thread");
        writeControlThread.setPriority(Math.min(Thread.currentThread()
                .getPriority() + 2, Thread.MAX_PRIORITY));
        writeControlThread.setDaemon(true);
        writeControlThread.start();

        // start writer and reader, and wait 10 minutes
        WriteDoc wdoc = new WriteDoc(trackingIndexWriter, searcherManager);
        ReadDoc rdoc = new ReadDoc(searcherManager);

        ExecutorService exman = Executors.newFixedThreadPool(5);
        exman.submit(wdoc);
        exman.submit(rdoc);

        Thread.sleep(1L * 60L * 1000L);

        exman.shutdown();
        exman.awaitTermination(5, TimeUnit.SECONDS);

        System.out.println("Closing...");

        writeControlThread.close();
        searcherManager.close();
        indexWriter.close();
        dir.close();

    }

}

package kr.nsri.lucene440;

import java.util.Calendar;
import java.util.Random;
import java.util.concurrent.Callable;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ReferenceManager;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;

public class ReadDoc implements Callable<Long> {

    private ReferenceManager<IndexSearcher> searcherManager;
    private final Random rand = new Random(Calendar.getInstance()
            .getTimeInMillis());
    private Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_44);
    private QueryParser parser = new QueryParser(Version.LUCENE_44, "content",
            analyzer);

    public ReadDoc(ReferenceManager<IndexSearcher> searchManager) {
        this.searcherManager = searchManager;
    }

    @Override
    public Long call() {
        while (true) {
            try {
                if (Thread.interrupted())
                    break;
                //
                // get index searcher from searcherManager
                //
                IndexSearcher wsrch = searcherManager.acquire();
                //
                // read current status
                //
                System.out.println("------------------ total count: "
                        + wsrch.collectionStatistics("content").docCount());
                Query query = parser.parse("abcde");
                TopDocs topDocs = wsrch.search(query, null, 2000);
                ScoreDoc[] scoreDocs = topDocs.scoreDocs;
                for (ScoreDoc sd : scoreDocs) {
                    Document wd = wsrch.doc(sd.doc);
                    System.out.println("\tRead: " + wd.get("content"));
                }
                //
                // release index searcher for reopen handling
                //
                searcherManager.release(wsrch);
                //
                // random wait
                //
                if (Thread.interrupted())
                    break;
                Thread.sleep(rand.nextInt(15000));
            } catch (Exception e) {
                break;
            }
        }

        return 0L;

    }
}

package kr.nsri.lucene440;

import java.io.IOException;
import java.util.Calendar;
import java.util.Random;
import java.util.concurrent.Callable;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.LongField;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.TrackingIndexWriter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ReferenceManager;

public class WriteDoc implements Callable<Long> {

    private TrackingIndexWriter trackingIndexWriter;
    private ReferenceManager<IndexSearcher> searcherManager;
    private final Random rand = new Random(Calendar.getInstance()
            .getTimeInMillis());

    public WriteDoc(TrackingIndexWriter trackingIndexWriter,
            ReferenceManager<IndexSearcher> searcherManager) {
        this.trackingIndexWriter = trackingIndexWriter;
        this.searcherManager = searcherManager;
    }

    @Override
    public Long call() {
        Long wcnt = 0L;
        while (true) {
            if (Thread.interrupted())
                break;
            Document doc = new Document();
            Long tweetID = rand.nextLong();
            String userName = anyWord();
            String content = anySentence();
            doc.add(new LongField("tweetID", tweetID, Store.YES));
            doc.add(new StringField("userScreenname", userName, Store.YES));
            doc.add(new TextField("content", content, Store.YES));
            try {
                //
                // add document
                //
                trackingIndexWriter.addDocument(doc);
                System.out.println("\t"+"new doc: "+content);
                //
                // signal searcher may be reopen to include new document
                //
                searcherManager.maybeRefresh();
                //
                // random wait
                //
                ++wcnt;
                if (Thread.interrupted())
                    break;
                Thread.sleep(rand.nextInt(15000));
            } catch (IOException | InterruptedException e) {
                break;
            }
        }

        return wcnt;
    }

    private String anyWord() {
        String r = "";
        String base = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        int wordLen = 1 + rand.nextInt(9);
        int baseLen = base.length();
        for (int wx = 0; wx < (1 + wordLen); ++wx)
            r += base.charAt(rand.nextInt(baseLen));
        return r;
    }

    private String anySentence() {
        String r = "";
        int wordCount = 1 + rand.nextInt(20);
        for (int wx = 0; wx < wordCount; ++wx)
            r += anyWord() + " ";
        return r + "abcde";
    }

}