asp.net - 从 ASP.NET Web 应用程序中使用 Lucene.Net 线程安全

Question

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

• 需要允许并发搜索和访问索引(查询并行运行)
• 会有多个索引
• 不要求索引搜索完全最新(“实时”)
• 运行作业以按一定频率更新索引(每个索引的频率不同)
• 显然，希望以遵循 lucene“最佳实践”并且能够良好执行和扩展的方式完成所有这些

我在这里找到了一些有用的资源，以及一些很好的问题，例如 this one

按照该帖子的指导，我决定尝试使用单例模式，其中包含为管理索引而构建的包装器的并发字典。

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

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;
                }
            }
        }
    }
}

理论上，这应该允许索引的线程安全单例实例(此处名为“index-test”)，其中我有两个公开公开的方法，Search() 和 Write() 可以从 ASP.NET Web 应用程序中调用而无需担心线程安全吗？ (如果这是不正确的，请告诉我)。

现在有一件事给我带来了一点麻烦:

如何在 Global.asax.cs 文件中的 Application_End 上优雅地关闭这些实例，这样如果我想在 IIS 中重新启动我的 Web 应用程序，我就不会收到大量写入.锁定失败等？

目前我能想到的是:

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

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

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

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

Answer 1

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

也就是说，更大的问题是从 ASP.NET 使用 Lucene.NET。 ASP.NET recycles the application pool for a number of reasons但是，在关闭一个应用程序域时，它会启动另一个应用程序域来处理对该站点的新请求。

如果您尝试使用不同的 IndexWriter/IndexReader 访问相同的物理文件(假设您使用的是基于文件系统的 FSDirectory) >，那么您将收到错误，因为尚未关闭的应用程序域尚未释放文件上的锁定。

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

这种方式需要更多工作(因为您必须创建所有抽象来表示您的操作)，但您可以获得以下好处:

• 服务进程将始终处于运行状态，这意味着客户端(ASP.NET 应用程序)不必担心争夺 FSDirectory 所需的文件。他们只需调用该服务即可。

• 您正在更高级别上抽象您的搜索操作。您不是直接访问 Lucene.NET，而是定义这些操作所需的操作和类型。一旦您将其抽象出来，如果您决定从 Lucene.NET 迁移到其他搜索机制(例如 RavenDB )，那么就需要更改合约的实现。