我有一个 .NET Core 2.0 应用程序，我在其中迭代了许多不同大小(总共 220GB)的文件(600,000 个)。

我用

new DirectoryInfo(TargetPath)
    .EnumerateFiles("*.*", SearchOption.AllDirectories)
    .GetEnumerator()

并使用

Parallel.ForEach(contentList.GetConsumingEnumerable(),
    new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount * 2
    },
    file => ...

在其中，我有一个正则表达式列表，然后我使用它扫描文件

Parallel.ForEach(_Rules,
    new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount * 2
    },
    rule => ... 

最后，我使用 Regex 类的实例进行匹配

RegEx = new Regex(
    Pattern.ToLowerInvariant(),
    RegexOptions.Multiline | RegexOptions.Compiled,
    TimeSpan.FromSeconds(_MaxSearchTime))

这个实例在所有文件中共享，所以我编译它一次。有 175 种模式应用于文件。

在随机(ish)点，应用程序死锁并且完全没有响应。再多的 try/catch 也无法阻止这种情况的发生。如果我使用完全相同的代码并为 .NET Framework 4.6 编译它，它可以毫无问题地工作。

我已经尝试了很多东西，我目前的测试似乎有效(但我非常谨慎!)是不使用实例，而是调用 STATIC Regex.Matches 方法每次。我不知道我在性能上受到了多大的打击，但至少我没有陷入僵局。

我可以使用一些见解或至少作为一个警示故事。

更新: 我得到这样的文件列表:

private void GetFiles(string TargetPath, BlockingCollection<FileInfo> ContentCollector)
    {
        List<FileInfo> results = new List<FileInfo>();
        IEnumerator<FileInfo> fileEnum = null;
        FileInfo file = null;
        fileEnum = new DirectoryInfo(TargetPath).EnumerateFiles("*.*", SearchOption.AllDirectories).GetEnumerator();
        while (fileEnum.MoveNext())
        {
            try
            {
                file = fileEnum.Current;
                //Skip long file names to mimic .Net Framework deficiencies
                if (file.FullName.Length > 256) continue;
                ContentCollector.Add(file);
            }
            catch { }
        }
        ContentCollector.CompleteAdding();
    }

在我的规则类中，以下是相关方法:

_RegEx = new Regex(Pattern.ToLowerInvariant(), RegexOptions.Multiline | RegexOptions.Compiled, TimeSpan.FromSeconds(_MaxSearchTime));
...
    public MatchCollection Matches(string Input) { try { return _RegEx.Matches(Input); } catch { return null; } }
    public MatchCollection Matches2(string Input) { try { return Regex.Matches(Input, Pattern.ToLowerInvariant(), RegexOptions.Multiline, TimeSpan.FromSeconds(_MaxSearchTime)); } catch { return null; } }

那么，这里是匹配代码:

    public List<SearchResult> GetMatches(string TargetPath)
    {
        //Set up the concurrent containers
        ConcurrentBag<SearchResult> results = new ConcurrentBag<SearchResult>();
        BlockingCollection<FileInfo> contentList = new BlockingCollection<FileInfo>();

        //Start getting the file list
        Task collector = Task.Run(() => { GetFiles(TargetPath, contentList); });
        int cnt = 0;
        //Start processing the files.
        Task matcher = Task.Run(() =>
        {
            //Process each file making it as parallel as possible                
            Parallel.ForEach(contentList.GetConsumingEnumerable(), new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 }, file =>
            {
                //Read in the whole file and make it lowercase
                //This makes it so the Regex engine does not have
                //to do it for each 175 patterns!
                StreamReader stream = new StreamReader(File.OpenRead(file.FullName));
                string inputString = stream.ReadToEnd();
                stream.Close();
                string inputStringLC = inputString.ToLowerInvariant();

                //Run through all the patterns as parallel as possible
                Parallel.ForEach(_Rules, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 }, rule =>
                {
                    MatchCollection matches = null;
                    int matchCount = 0;
                    Stopwatch ruleTimer = Stopwatch.StartNew();

                    //Run the match for the rule and then get our count (does the actual match iteration)
                    try
                    {
                        //This does not work - Causes Deadlocks:
                        //matches = rule.Matches(inputStringLC);

                        //This works - No Deadlocks;
                        matches = rule.Matches2(inputStringLC);

                        //Process the regex by calling .Count()
                        if (matches == null) matchCount = 0;
                        else matchCount = matches.Count;
                    }

                    //Catch timeouts
                    catch (Exception ex)
                    {
                        //Log the error
                        string timeoutMessage = String.Format("****** Regex Timeout: {0} ===> {1} ===> {2}", ruleTimer.Elapsed, rule.Pattern, file.FullName);
                        Console.WriteLine(timeoutMessage);
                        matchCount = 0;
                    }
                    ruleTimer.Stop();

                    if (matchCount > 0)
                    {
                        cnt++;
                        //Iterate the matches and generate our match records
                        foreach (Match match in matches)
                        {
                            //Fill my result object
                            //...

                            //Add the result to the collection
                            results.Add(result);
                        }
                    }
                });
            });
        });

        //Wait until all are done.
        Task.WaitAll(collector, matcher);

        Console.WriteLine("Found {0:n0} files with {1:n0} matches", cnt, results.Count);


        return results.ToList();
    }

更新 2 我跑的测试没有死锁，但是接近尾声的时候好像卡顿了，不过还是可以用VS打入进程。然后我意识到我没有在我的测试中设置超时，而我在我发布的代码中设置了超时(rule.Matches 和 rule.Matches2)。 WITH超时，它会死锁。 WITHOUT 超时，它不会。两者仍然适用于 .Net Framework 4.6。我需要正则表达式超时，因为有一些大文件导致某些模式停止。

更新 3: 我一直在研究超时值，它似乎是线程运行、超时异常和导致 Regex 引擎死锁的超时值的某种组合。我无法准确确定，但超时 >= 5 分钟似乎有帮助。作为临时修复，我可能会将值设置为 10 分钟，但这不是永久修复!

最佳答案

如果我猜的话，我会责怪正则表达式

• RegexOptions.Compiled 未在 .NET Core 2.0 ( source ) 中实现
• 您的 175 个模式中的一些可能是 slightly evil

这可能会导致 .NET Framework 4.6 和 .NET Core 2.0 之间出现显着的性能差异，从而导致应用程序无响应。

关于c# - .NET Core 2.0 正则表达式超时死锁，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50356774/