10

因此，我一直在研究从 Web 应用程序中实现 Lucene.Net 索引搜索和写入的最佳方法。我提出以下要求：

  • 需要允许并发搜索和访问索引（查询并行运行）
  • 会有多个索引
  • 索引搜索完全是最新的（“实时”）不是必需的
  • 运行作业以某种频率更新索引（每个索引的频率不同）
  • 显然，希望以遵循 lucene“最佳实践”并且可以很好地执行和扩展的方式来完成所有这些

我找到了一些有用的资源，以及一些关于 SO 的好问题，比如这个

按照那篇文章的指导，我决定尝试一个单例模式，其中包含一个为管理索引而构建的包装器的并发字典。

为了简单起见，我假设我只管理一个索引，在这种情况下，包装器可以成为单例。这最终看起来像这样：

public sealed class SingleIndexManager
{
    private const string IndexDirectory = "C:\\IndexDirectory\\";
    private const string IndexName = "test-index";
    private static readonly Version _version = Version.LUCENE_29;

    #region Singleton Behavior
    private static volatile SingleIndexManager _instance;
    private static object syncRoot = new Object();

    public static SingleIndexManager Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (syncRoot)
                {
                    if (_instance == null)
                        _instance = new SingleIndexManager();
                }
            }

            return _instance;
        }
    }
    #endregion

    private IndexWriter _writer;
    private IndexSearcher _searcher;

    private int _activeSearches = 0;
    private int _activeWrites = 0;

    private SingleIndexManager()
    {
        lock(syncRoot)
        {
            _writer = CreateWriter(); //hidden for sake of brevity
            _searcher = new IndexSearcher(_writer.GetReader());
        }
    }

    public List<Document> Search(Func<IndexSearcher,List<Document>> searchMethod)
    {
        lock(syncRoot)
        {
            if(_searcher != null && !_searcher.GetIndexReader().IsCurrent() && _activeSearches == 0)
            {
                _searcher.Close();
                _searcher = null;
            }
            if(_searcher == null)
            {
                _searcher = new IndexSearcher((_writer ?? (_writer = CreateWriter())).GetReader());
            }
        }
        List<Document> results;
        Interlocked.Increment(ref _activeSearches);
        try
        {
            results = searchMethod(_searcher);
        } 
        finally
        {
            Interlocked.Decrement(ref _activeSearches);
        }
        return results;
    }

    public void Write(List<Document> docs)
    {
        lock(syncRoot)
        {
            if(_writer == null)
            {
                _writer = CreateWriter();
            }
        }
        try
        {
            Interlocked.Increment(ref _activeWrites);
            foreach (Document document in docs)
            {
                _writer.AddDocument(document, new StandardAnalyzer(_version));
            }

        } 
        finally
        {
            lock(syncRoot)
            {
                int writers = Interlocked.Decrement(ref _activeWrites);
                if(writers == 0)
                {
                    _writer.Close();
                    _writer = null;
                }
            }
        }
    }
}

从理论上讲，这应该允许索引的线程安全单例实例（这里称为“索引测试”），其中我有两个公开公开的方法，Search()可以Write()从 ASP.NET Web 应用程序中调用，而无需担心线程安全？（如果这不正确，请告诉我）。

现在有一件事给我带来了一些麻烦：

如何Application_End在 Global.asax.cs 文件中优雅地关闭这些实例，以便如果我想在 IIS 中重新启动我的 Web 应用程序，我不会遇到一堆 write.lock 失败等？

目前我能想到的只有：

public void Close()
{
    lock(syncRoot)
    {
        _searcher.Close();
        _searcher.Dispose();
        _searcher = null;

        _writer.Close();
        _writer.Dispose();
        _writer = null;
    }
}

并调用它Application_End，但如果我有任何活跃的搜索者或作者，这会导致索引损坏吗？

非常感谢任何帮助或建议。谢谢。

4

3 回答 3

11

Lucene.NET 是非常线程安全的。我可以肯定地说IndexWriter和IndexReader类上的所有方法都是线程安全的，您可以使用它们而不必担心同步。您可以摆脱所有涉及围绕这些类的实例进行同步的代码。

也就是说，更大的问题是使用来自 ASP.NET 的 Lucene.NET。 ASP.NET 出于多种原因回收应用程序池，但是，在关闭一个应用程序域时，它会启动另一个应用程序域来处理对站点的新请求。

如果您尝试使用FSDirectory不同的IndexWriter/访问相同的物理文件（假设您使用的是基于文件系统的文件） IndexReader，那么您将收到一个错误，因为该文件的锁定尚未由尚未释放的应用程序域释放还没有被关闭。

为此，推荐的最佳实践是控制处理对 Lucene.NET 的访问的进程；这通常意味着创建一个服务，您可以在其中通过 Remoting 或 WCF（最好是后者）公开您的操作。

这样做的工作量更大（因为您必须创建所有抽象来表示您的操作），但您可以获得以下好处：

  • 服务进程将始终启动，这意味着客户端（ASP.NET 应用程序）不必担心争夺所需文件FSDirectory。他们只需要调用服务即可。

  • 您正在更高层次上抽象您的搜索操作。您不是直接访问 Lucene.NET，而是定义这些操作所需的操作和类型。一旦你把它抽象出来，如果你决定从 Lucene.NET 转移到其他搜索机制（比如RavenDB），那么就需要改变合同的实现了。

于 2012-08-20T14:42:24.130 回答
3
  • 打开 IndexWriter 可能是一项繁重的操作。你可以重复使用它。
  • 在 Write(...) 中有一个锁以确保事务行为，在方法返回之前将所有文档添加并写入磁盘。对 Commit() 的调用可能是一个冗长的操作（它可能导致段合并）。如果需要，您可以将其移动到后台线程（这会引入一些添加的文档在提交中写入的场景，一些在另一个中）。
  • 在您的 Search(...) 方法中不需要无条件锁定。你可以检查你是否有一个 _searcher 实例，并使用它。在 Write(...) 中将其设置为 null 以强制使用新的搜索器。
  • 我不确定您是否使用了 searchMethod，它看起来像是收集器更适合的东西。


public sealed class SingleIndexManager {
    private static readonly Version _version = Version.LUCENE_29;
    private readonly IndexWriter _writer;
    private volatile IndexSearcher _searcher;
    private readonly Object _searcherLock = new Object();

    private SingleIndexManager() {
        _writer = null; // TODO
    }

    public List<Document> Search(Func<IndexSearcher, List<Document>> searchMethod) {
        var searcher = _searcher;
        if (searcher == null) {
            lock (_searcherLock) {
                if (_searcher == null) {
                    var reader = _writer.GetReader();
                    _searcher = searcher = new IndexSearcher(reader);
                }
            }
        }

        return searchMethod(searcher);
    }

    public void Write(List<Document> docs) {
        lock (_writer) {
            foreach (var document in docs) {
                _writer.AddDocument(document, new StandardAnalyzer(_version));
            }

            _writer.Commit();
            _searcher = null;
        }
    }
}
于 2012-08-20T14:47:17.687 回答
1

您还可以在 IIS 中禁用应用程序池重叠设置，以避免在一个应用程序池关闭（但仍持有 write.lock）并且 IIS 正在为新请求准备另一个应用程序池时出现 Lucene write.lock 问题。

于 2014-04-19T18:50:05.677 回答