Question

我正在创建一个Windows窗体应用程序，在其中我选择一个包含多个* .txt文件的文件夹。它们的长度可以从几千行（kB）到多达50百万行（1GB）不等。代码的每一行都有三个信息。 long中的日期，int中的location id和float中的值都以分号（;）分隔。我需要计算所有这些文件中的最小值和最大值，并告诉它是哪个文件，然后是最常用的值。

我已将这些文件验证并存储在arraylist中。我打开一个线程来逐个读取文件，我逐行读取数据。它工作正常，但当有1GB文件时，我的内存不足。我试图将值存储在字典中，其中key是日期，值将是一个对象，其中包含从该行加载的所有信息以及文件名。我看到我不能使用字典，因为在大约6M的值时，我的内存不足。所以我应该在多线程中做到这一点。我虽然可以运行两个线程，一个读取文件并将信息放入某种容器中，另一个读取它并进行计算，然后从容器中删除值。但我不知道哪个容器可以做这样的事情。此外，我需要计算最频繁的值，所以他们需要存储在某个地方，这会导致我回到某种字典，但我已经知道我将耗尽内存。我对线程也没有多少经验，所以我不知道什么是可能的。到目前为止，这是我的代码：

GUI：

namespace STI {
    public partial class GUI : Form {
        private String path = null;
        public static ArrayList txtFiles;

        public GUI() {
            InitializeComponent();
            _GUI1 = this;
        }

       //I run it in thread. I thought I would run the second 
       //one here that would work with the values inputed in some container
        private void buttonRun_Click(object sender, EventArgs e) {
            ThreadDataProcessing processing = new ThreadDataProcessing();
            Thread t_process = new Thread(processing.runProcessing);
            t_process.Start();

            //ThreadDataCalculating calculating = new ThreadDataCalculating();
            //Thread t_calc = new Thread(calculating.runCalculation());
            //t_calc.Start();

        }


    }
}

ThreadProcessing.cs

namespace STI.thread_package {
    class ThreadDataProcessing {
        public static Dictionary<long, object> finalMap = new Dictionary<long, object>();

        public void runProcessing() {
            foreach (FileInfo file in GUI.txtFiles) {
                using (FileStream fs = File.Open(file.FullName.ToString(), FileMode.Open))
                using (BufferedStream bs = new BufferedStream(fs))
                using (StreamReader sr = new StreamReader(bs)) {
                    String line;
                    String[] splitted;
                    try { 
                        while ((line = sr.ReadLine()) != null) {
                            splitted = line.Split(';');

                            if (splitted.Length == 3) {
                                long date = long.Parse(splitted[0]);
                                int location = int.Parse(splitted[1]);
                                float value = float.Parse(splitted[2], CultureInfo.InvariantCulture);

                                Entry entry = new Entry(date, location, value, file.Name);

                                if (!finalMap.ContainsKey(entry.getDate())) {
                                    finalMap.Add(entry.getDate(), entry);

                                }
                            }
                        }
                        GUI._GUI1.update("File \"" + file.Name + "\" completed\n");
                    }
                    catch (FormatException ex) {
                        GUI._GUI1.update("Wrong file format.");
                    }
                    catch (OutOfMemoryException) {
                        GUI._GUI1.update("Out of memory");
                    }
                }

            }
        }
    }
}

以及我从行中放置值的对象： Entry.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace STI.entities_package {
    class Entry {
        private long date;
        private int location;
        private float value;
        private String fileName;
        private int count;

        public Entry(long date, int location, float value, String fileName) {
            this.date = date;
            this.location = location;
            this.value = value;
            this.fileName = fileName;

            this.count = 1;
        }

        public long getDate() {
            return date;
        }

        public int getLocation() {
            return location;
        }

        public String getFileName() {
            return fileName;
        }

    }
}

Answer 1

我不认为多线程会在这里帮助你 - 它可以帮助你将IO绑定任务与CPU绑定任务分开，但你的CPU绑定任务是如此微不足道，我不认为他们保证他们自己的线程。所有多线程都将不必要地增加问题的复杂性。

计算常量内存中的最小值/最大值是微不足道的：只保留当前文件的值小于minFile或大于maxFile时更新的minFile和maxFile变量。找到最频繁的值将需要更多的内存，但只有几百万个文件你应该有足够的RAM来存储Dictionary<float, int>来保持每个值的频率，之后你遍历地图来确定哪个值的频率最高。如果由于某种原因你没有足够的RAM（确保你的文件被关闭并且如果你的内存不足则收集垃圾，因为一个有几百万条目的Dictionary<float, int>应该小于一个千兆字节的RAM）然后你可以对文件进行多次传递：在第一次传递时将值存储在Dictionary<interval, int>中，你将MIN_FLOAT和MAX_FLOAT之间的间隔分成几千个子间隔，然后在下一个传递中，您可以忽略所有不适合频率最高的区间的值，从而缩小字典的大小。但是，Dictionary<float, int>应该适合内存，所以除非您开始处理数十亿个文件而不是数百万个文件，否则您可能不需要多次传递过程。

在C＃中使用多线程处理多个文件的最佳方法是什么？

1 个答案: