大文本文件中的词频

Question

我正在尝试读取一个大文本文件，并在其中输出不同的单词以及计数。 到目前为止，我已经尝试了几次，这是迄今为止我提出的最快的解决方案。

private static readonly char[] separators = { ' ' };

public IDictionary<string, int> Parse(string path)
{
    var wordCount = new Dictionary<string, int>();

    using (var fileStream = File.Open(path, FileMode.Open, FileAccess.Read))
    using (var streamReader = new StreamReader(fileStream))
    {
        string line;
        while ((line = streamReader.ReadLine()) != null)
        {
            var words = line.Split(separators, StringSplitOptions.RemoveEmptyEntries);

            foreach (var word in words)
            {
                if (wordCount.ContainsKey(word))
                {
                    wordCount[word] = wordCount[word] + 1;
                }
                else
                {
                    wordCount.Add(word, 1);
                }
            }
        }
    }

    return wordCount;
}

我如何衡量我的解决方案

我有200MB的文本，我知道该文本的总字数（通过文本编辑器）。 我正在使用Stopwatch class ，对单词进行计数以确保准确性并计算花费的时间。 到目前为止，大约需要9秒钟。

其他尝试

• 我试图利用多线程通过TPL库将工作拆分出来。 这涉及批处理多行，将批处理的处理发送到单独的任务，并在字典中锁定读/写操作。 但是，这似乎无法为我提供任何性能改进。
• 花了大约30秒。 我怀疑要对字典进行读写操作的锁定成本太高，无法获得任何性能。
• 我还查看了ConcurrentDictionary类型，但是根据我的理解， AddOrUpdate方法确实需要调用代码来处理同步，并且没有带来任何性能好处。

我敢肯定，有一个更快的方法可以实现这一目标！ 是否有更好的数据结构可用于此问题？

欢迎对我的解决方案提出任何建议/批评-尝试在此处学习和改进！

干杯。

更新：这是我正在使用的测试文件的链接 。

Answer 1

我能给出的最好的简短答案是测量，测量，测量。 Stopwatch可以很好地了解花在哪里的时间，但是最终您最终会在上面花很多代码，否则您将不得不为此目的找到更好的工具。 我建议为此使用专用的探查器工具，其中有许多可用于C＃和.NET的工具。

---

我分三步设法节省了约43％的总运行时间。

首先，我测量了您的代码并得到了：

这似乎表明这里有两个热点我们可以尝试解决：

1. 字符串拆分（SplitInternal）
2. 字典维护（FindEntry，Insert，get_Item）

花的最后一部分时间是在读取文件时，我真的怀疑通过更改代码的这一部分能否获得很多收益。 这里的另一个答案提到使用特定的缓冲区大小，我尝试了这一点，但无法获得可测量的差异。

第一个是字符串拆分，虽然有点容易，但需要重写一个非常简单的string.Split调用， string.Split拆分为更多代码。 我将处理一行的循环重写为：

while ((line = streamReader.ReadLine()) != null)
{
    int lastPos = 0;
    for (int index = 0; index <= line.Length; index++)
    {
        if (index == line.Length || line[index] == ' ')
        {
            if (lastPos < index)
            {
                string word = line.Substring(lastPos, index - lastPos);
                // process word here
            }
            lastPos = index + 1;
        }
    }
}

然后，我将一个单词的处理重写为此：

int currentCount;
wordCount.TryGetValue(word, out currentCount);
wordCount[word] = currentCount + 1;

这取决于以下事实：

1. TryGetValue比检查单词是否存在然后检索其当前计数便宜
2. 如果TryGetValue无法获取值（键不存在），则它将在此处将currentCount变量初始化为其默认值0。这意味着我们实际上不需要检查该单词是否确实存在。
3. 我们可以通过索引器向字典添加新单词（它将覆盖现有值或向字典添加新的键值）

因此，最终循环如下所示：

while ((line = streamReader.ReadLine()) != null)
{
    int lastPos = 0;
    for (int index = 0; index <= line.Length; index++)
    {
        if (index == line.Length || line[index] == ' ')
        {
            if (lastPos < index)
            {
                string word = line.Substring(lastPos, index - lastPos);
                int currentCount;
                wordCount.TryGetValue(word, out currentCount);
                wordCount[word] = currentCount + 1;
            }
            lastPos = index + 1;
        }
    }
}

新的度量显示：

细节：

1. 我们从6876ms变为5013ms
2. 我们浪费了花在SplitInternal ， FindEntry和get_Item
3. 我们花了一些时间在TryGetValue和Substring

以下是差异的详细信息：

如您所见，我们损失的时间超过了获得新时间的时间，从而带来了净改进。

但是，我们可以做得更好。 我们在这里进行2次字典查找，其中涉及计算单词的哈希码，并将其与字典中的键进行比较。 第一个查询是TryGetValue的一部分，第二个查询是wordCount[word] = ... 。

我们可以通过在字典内创建更智能的数据结构来删除第二个字典查找，但要消耗更多的堆内存。

我们可以使用Xanatos的把计数存储在对象中的技巧，以便删除第二个字典查找：

public class WordCount
{
    public int Count;
}

...

var wordCount = new Dictionary<string, WordCount>();

...

string word = line.Substring(lastPos, index - lastPos);
WordCount currentCount;
if (!wordCount.TryGetValue(word, out currentCount))
    wordCount[word] = currentCount = new WordCount();
currentCount.Count++;

这只会从字典中检索计数，另外1次额外出现不涉及字典。 方法的结果也将更改为以字典的一部分而不是int形式返回此WordCount类型。

最终结果：节省了约43％。

最后一段代码：

public class WordCount
{
    public int Count;
}

public static IDictionary<string, WordCount> Parse(string path)
{
    var wordCount = new Dictionary<string, WordCount>();

    using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None, 65536))
    using (var streamReader = new StreamReader(fileStream, Encoding.Default, false, 65536))
    {
        string line;
        while ((line = streamReader.ReadLine()) != null)
        {
            int lastPos = 0;
            for (int index = 0; index <= line.Length; index++)
            {
                if (index == line.Length || line[index] == ' ')
                {
                    if (lastPos < index)
                    {
                        string word = line.Substring(lastPos, index - lastPos);
                        WordCount currentCount;
                        if (!wordCount.TryGetValue(word, out currentCount))
                            wordCount[word] = currentCount = new WordCount();
                        currentCount.Count++;
                    }
                    lastPos = index + 1;
                }
            }
        }
    }

    return wordCount;
}

Answer 2

您的方法似乎符合大多数人的处理方式。 您应该正确地注意到，使用多线程并没有带来任何明显的好处，因为瓶颈很可能是IO约束，并且无论您拥有哪种硬件，您读取的速度都不会比硬件支持的速度快。

如果您确实在寻求速度上的提高（我怀疑您会获得任何提高），则可以尝试实现生产者-消费者模式，其中一个线程读取文件，其他线程处理行（也许然后并行检查单词中的单词）线）。 这里需要权衡的是，您要添加很多复杂的代码以换取微不足道的改进（只有基准测试才能确定这一点）。

http://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem

编辑：也看看ConcurrentDictionary

Answer 3

只需更改一下，我就获得了很多好处（从200秒的文件中从25秒增加到20秒）：

int cnt;

if (wordCount.TryGetValue(word, out cnt))
{
    wordCount[word] = cnt + 1;
}
else
....

基于ConcurrentDictionary<>和Parallel.ForEach变体（使用IEnumerable<>重载）。 请注意，不是使用int ，而是使用InterlockedInt ，该InterlockedInt使用Interlocked.Increment来递增自身。 作为引用类型，它可以与ConcurrentDictionary<>.GetOrAdd ...一起正常使用ConcurrentDictionary<>.GetOrAdd

public class InterlockedInt
{
    private int cnt;

    public int Cnt
    {
        get
        {
            return cnt;
        }
    }

    public void Increment()
    {
        Interlocked.Increment(ref cnt);
    }
}

public static IDictionary<string, InterlockedInt> Parse(string path)
{
    var wordCount = new ConcurrentDictionary<string, InterlockedInt>();

    Action<string> action = line2 =>
    {
        var words = line2.Split(separators, StringSplitOptions.RemoveEmptyEntries);

        foreach (var word in words)
        {
            wordCount.GetOrAdd(word, x => new InterlockedInt()).Increment();
        }
    };

    IEnumerable<string> lines = File.ReadLines(path);
    Parallel.ForEach(lines, action);

    return wordCount;
}

请注意，使用Parallel.ForEach的效率要比直接为每个物理核心使用一个线程低（您可以在历史记录中看到效果）。 虽然这两种解决方案在我的PC上花费的挂墙时钟都不到10秒，但Parallel.ForEach占用的CPU时间为55秒，而Thread解决方案的时间为33秒。

还有另一种技巧，其价值约为5-10％：

public static IEnumerable<T[]> ToBlock<T>(IEnumerable<T> source, int num)
{
    var array = new T[num];
    int cnt = 0;

    foreach (T row in source)
    {
        array[cnt] = row;
        cnt++;

        if (cnt == num)
        {
            yield return array;
            array = new T[num];
            cnt = 0;
        }
    }

    if (cnt != 0)
    {
        Array.Resize(ref array, cnt);
        yield return array;
    }
}

您将数据包中的行“分组”（选择10到100之间的数字），以便减少线程内通信。 然后，工作人员必须对收到的行进行一次foreach 。

Answer 4

使用200mb的文本文件，以下内容在我的计算机上花费了不到5秒的时间。

    class Program
{
    private static readonly char[] separators = { ' ' };
    private static List<string> lines;
    private static ConcurrentDictionary<string, int> freqeuncyDictionary;

    static void Main(string[] args)
    {
        var stopwatch = new System.Diagnostics.Stopwatch();
        stopwatch.Start();

        string path = @"C:\Users\James\Desktop\New Text Document.txt";
        lines = ReadLines(path);
        ConcurrentDictionary<string, int> test = GetFrequencyFromLines(lines);

        stopwatch.Stop();
        Console.WriteLine(@"Complete after: " + stopwatch.Elapsed.TotalSeconds);
    }

    private static List<string> ReadLines(string path)
    {
        lines = new List<string>();
        using (var fileStream = File.Open(path, FileMode.Open, FileAccess.Read))
        {
            using (var streamReader = new StreamReader(fileStream))
            {
                string line;
                while ((line = streamReader.ReadLine()) != null)
                {
                    lines.Add(line);
                }
            }
        }
        return lines;            
    }

    public static ConcurrentDictionary<string, int> GetFrequencyFromLines(List<string> lines)
    {
        freqeuncyDictionary = new ConcurrentDictionary<string, int>();
        Parallel.ForEach(lines, line =>
        {
            var words = line.Split(separators, StringSplitOptions.RemoveEmptyEntries);

            foreach (var word in words)
            {
                if (freqeuncyDictionary.ContainsKey(word))
                {
                    freqeuncyDictionary[word] = freqeuncyDictionary[word] + 1;
                }
                else
                {
                    freqeuncyDictionary.AddOrUpdate(word, 1, (key, oldValue) => oldValue + 1);
                }
            }
        });

        return freqeuncyDictionary;
    }
}

Answer 5

如果您要计算一个特定的单词，可以使用此处链接的strtok函数，并将每个单词与您要评估的单词进行比较，我认为这不是很昂贵，但是我从来没有尝试过使用大文件夹。 。

Answer 6

我建议将流缓冲区的大小设置为更大并匹配：

    using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 8192))
    using (var streamReader = new StreamReader(fileStream, Encoding.UTF8, false, 8192))

首先，您的代码导致缓冲区太小，无法进行此类工作。 其次，由于读取器的缓冲区小于流的缓冲区，因此首先将数据复制到流的缓冲区，然后再复制到读取器的缓冲区。 对于您正在做的工作，这可能是性能的破坏者。

当缓冲区大小匹配时，将永远不会使用流的缓冲区-实际上，永远不会分配它。