1

我有一个应用程序需要.CSV在应用程序启动时读取非常大的文件并将每一行转换为object. 这些是读取文件的方法：

public List<Aobject> GetAobject()
    {
        List<Aobject> Aobjects = new List<Aobject>();

        using (StreamReader sr = new StreamReader(pathA, Encoding.GetEncoding("Windows-1255")))
        {
            string line;
            while ((line = sr.ReadLine()) != null)
            {
                string[] spl = line.Split(',');
                Aobject p = new Aobject { Aprop = spl[0].Trim(), Bprop = spl[1].Trim(), Cprop = spl[2].Trim() };
                Aobjects.Add(p);
            }
        }

        return Aobjects;
    }

    public List<Bobject> GetBobject()
    {
        List<Bobject> Bobjects = new List<Bobject>();

        using (StreamReader sr =
           new StreamReader(pathB, Encoding.GetEncoding("Windows-1255")))
        {
            //parts.Clear();
            string line;
            while ((line = sr.ReadLine()) != null)
            {
                string[] spl = line.Split(',');
                Bobject p = new Bobject();
                p.Cat = spl[0];
                p.Name = spl[1];
                p.Serial1 = spl[3].ToUpper().Contains("1");
                if (spl[4].StartsWith("1"))
                    p.Technical = 1;
                else if (spl[4].StartsWith("2"))
                    p.Technical = 2;
                else
                    p.Technical = 0;
                Bobjects.Add(p);
            }
        }

        return Bobjects;
    }

这阻碍了我UI几秒钟，所以我试着做到了multi-Threaded。但是我所有的测试都表明该un-threaded场景更快。这就是我测试它的方式：

 Stopwatch sw = new Stopwatch();
            sw.Start();

            for (int i = 0; i < 1000; i++)
            {
                Dal dal = new Dal();
                Thread a = new Thread(() => { ThreadedAobjects = dal.GetAobject(); });
                Thread b = new Thread(() => { ThreadedBobjects = dal.GetBobject(); });

                a.Start();
                b.Start();

                b.Join();
                a.Join();
            }
            sw.Stop();

            txtThreaded.Text = sw.Elapsed.ToString();

            Stopwatch sw2 = new Stopwatch();
            sw2.Start();

            for (int i = 0; i < 1000; i++)
            {
                Dal dal2 = new Dal();
                NonThreadedAobjects = dal2.GetAobject();
                NonThreadedBobjects = dal2.GetBobject();
            }
            sw2.Stop();

            txtUnThreaded.Text = sw2.Elapsed.ToString();

结果：
Threaded run: 00:01:55.1378686
UnTreaded run:00:01:37.1197840
Compiled for.Net4.0但也应该在.Net3.5, 发布模式下工作。
有人可以解释为什么会发生这种情况，我该如何改进？

4

4 回答 4

5

您忽略了与创建和启动线程相关的成本。尝试使用线程池，而不是创建新线程：

ThreadPool.QueueUserWorkItem(() => { ThreadedAobjects = dal.GetAobject(); });

您还需要记录已完成的操作次数，以便正确计算总时间。看看这个链接：http: //msdn.microsoft.com/en-us/library/3dasc8as.aspx

于 2013-10-15T06:25:59.387 回答
1

我会建议一个调用GetAobject然后调用的单个线程GetBobject。您的任务几乎肯定是 I/O 绑定的，如果这两个文件非常大并且在同一个驱动器上，那么尝试同时访问它们将导致大量不必要的磁盘查找。所以你的代码变成：

ThreadPool.QueueUserWorkItem(() =>
{
    AObjects = GetAObject();
    BObjects = GetBObject();
});

这也简化了您的代码，因为您只需要同步一个ManualResetEvent.

于 2013-10-15T14:30:35.843 回答
0

如果您将运行此测试，您每次都会得到略有不同的结果。事情发生所花费的时间受到计算机运行时发生的许多事情的影响——例如：其他进程、GC 等。

但是您的结果是合理的，因为拥有另一个线程意味着处理器需要更多的上下文切换，并且每次上下文切换都需要时间......

您可以阅读更多关于上下文切换的信息： http ://en.wikipedia.org/wiki/Context_switch

于 2013-10-15T06:26:41.507 回答
0

添加到 Slugart 的正确答案：您的并行化在许多方面都无效，因为您等待第一个线程完成，而第二个线程可能会更快完成并且一段时间内什么都不做（查看任务并行库和 PLINQ）。

此外，您的操作是 IO 绑定的，这意味着并行性取决于 IO 设备（一些设备以顺序方式执行更好，并且尝试进行多次读取会减慢整体操作）。

于 2013-10-15T06:38:13.133 回答