c# – 如何在很大程度上依赖于I/O来平衡工作

我正在构建一个必须处理一堆数据的控制台应用程序。

基本上,应用程序从DB获取引用。对于每个引用,解析文件的内容并进行一些更改。这些文件是HTML文件,该进程正在使用RegEx替换(查找引用并将其转换为链接)进行大量工作。然后将结果存储在文件系统上并发送到外部系统。

如果我按顺序恢复过程:

var refs = GetReferencesFromDB(); // ~5000 Datarow returned
foreach(var ref in refs)
{
    var filePath = GetFilePath(ref); // This method looks up in a previously loaded file list
    var html = File.ReadAllText(filePath); // Read html locally, or from a network drive
    var convertedHtml = ParseHtml(html);
    File.WriteAllText(destinationFilePath); // Copy the result locally, or a network drive
    SendToWs(ref, convertedHtml);
}

我的程序正常工作,但速度相当慢。这就是为什么我要平行这个过程。

到目前为止,我做了一个简单的并行化添加AsParallel:

var refs = GetReferencesFromDB().AsParallel(); 
refs.ForAll(ref=>
{
    var filePath = GetFilePath(ref); 
    var html = File.ReadAllText(filePath); 
    var convertedHtml = ParseHtml(html);
    File.WriteAllText(destinationFilePath); 
    SendToWs(ref, convertedHtml);
});

这个简单的改变会减少过程的持续时间(减少25%的时间)。然而,我对并行化的理解是,如果并行化依赖于I / O的资源,则不会有太多的好处(或更糟的是,更少的好处),因为i / o不会神奇地加倍。

这就是为什么我认为我应该改变我的方法不是并行化整个过程,而是创建依赖链接排队的任务。

我应该创建一个流程:

Queue read file. When finished, Queue ParseHtml. When finished, Queue both send to WS and write locally. When finished, log the result.

但是,我不知道如何实现这样的想法。

我觉得它将以一组消费者/生产者队列结束,但是我没有找到正确的样本。

而且,我不知道是否会有好处。

感谢您的意见

[编辑]其实我是使用c#4.5的完美候选人,如果只是rtm 🙂

另一件让我觉得并不正确的事情是,在资源监视器中,我看到CPU,网络I / O和磁盘I / O不稳定的图形。当一个人高的时候,别人是低到中等的

您没有在任何代码中利用任何异步I / O API。您所做的一切都是CPU限制,所有的I / O操作都会浪费CPU资源的阻塞。 AsParallel适用于计算绑定任务,如果要利用异步I / O,您需要在< = v4.0中利用基于异步编程模型(APM)的API。这是通过在您正在使用的基于I / O的类上查找BeginXXX / EndXXX方法来完成的,并在可用时利用它们。 阅读这篇文章为初学者:TPL TaskFactory.FromAsync vs Tasks with blocking methods

接下来,你不想在这种情况下使用AsParallel。 AsParallel支持流式传输,这将导致每个项目立即安排一个新的任务,但您不需要/希望在这里。使用Parallel :: ForEach对工作进行分区可以更好地服务。

让我们看看如何使用这些知识在你的具体情况下实现最大并发性:

var refs = GetReferencesFromDB();

// Using Parallel::ForEach here will partition and process your data on separate worker threads
Parallel.ForEach(
    refs,
    ref =>
{ 
    string filePath = GetFilePath(ref);

    byte[] fileDataBuffer = new byte[1048576];

    // Need to use FileStream API directly so we can enable async I/O
    FileStream sourceFileStream = new FileStream(
                                      filePath, 
                                      FileMode.Open,
                                      FileAccess.Read,
                                      FileShare.Read,
                                      8192,
                                      true);

    // Use FromAsync to read the data from the file
    Task<int> readSourceFileStreamTask = Task.Factory.FromAsync(
                                             sourceFileStream.BeginRead
                                             sourceFileStream.EndRead
                                             fileDataBuffer,
                                             fileDataBuffer.Length,
                                             null);

    // Add a continuation that will fire when the async read is completed
    readSourceFileStreamTask.ContinueWith(readSourceFileStreamAntecedent =>
    {
        int soureFileStreamBytesRead;

        try
        {
            // Determine exactly how many bytes were read 
            // NOTE: this will propagate any potential exception that may have occurred in EndRead
            sourceFileStreamBytesRead = readSourceFileStreamAntecedent.Result;
        }
        finally
        {
            // Always clean up the source stream
            sourceFileStream.Close();
            sourceFileStream = null;
        }

        // This is here to make sure you don't end up trying to read files larger than this sample code can handle
        if(sourceFileStreamBytesRead == fileDataBuffer.Length)
        {
            throw new NotSupportedException("You need to implement reading files larger than 1MB. :P");
        }

        // Convert the file data to a string
        string html = Encoding.UTF8.GetString(fileDataBuffer, 0, sourceFileStreamBytesRead);

        // Parse the HTML
        string convertedHtml = ParseHtml(html);

        // This is here to make sure you don't end up trying to write files larger than this sample code can handle
        if(Encoding.UTF8.GetByteCount > fileDataBuffer.Length)
        {
            throw new NotSupportedException("You need to implement writing files larger than 1MB. :P");
        }

        // Convert the file data back to bytes for writing
        Encoding.UTF8.GetBytes(convertedHtml, 0, convertedHtml.Length, fileDataBuffer, 0);

        // Need to use FileStream API directly so we can enable async I/O
        FileStream destinationFileStream = new FileStream(
                                               destinationFilePath,
                                               FileMode.OpenOrCreate,
                                               FileAccess.Write,
                                               FileShare.None,
                                               8192,
                                               true);

        // Use FromAsync to read the data from the file
        Task destinationFileStreamWriteTask = Task.Factory.FromAsync(
                                                  destinationFileStream.BeginWrite,
                                                  destinationFileStream.EndWrite,
                                                  fileDataBuffer,
                                                  0,
                                                  fileDataBuffer.Length,
                                                  null);

        // Add a continuation that will fire when the async write is completed
        destinationFileStreamWriteTask.ContinueWith(destinationFileStreamWriteAntecedent =>
        {
            try
            {
                // NOTE: we call wait here to observe any potential exceptions that might have occurred in EndWrite
                destinationFileStreamWriteAntecedent.Wait();
            }
            finally
            {
                // Always close the destination file stream
                destinationFileStream.Close();
                destinationFileStream = null;
            }
        },
        TaskContinuationOptions.AttachedToParent);

        // Send to external system **concurrent** to writing to destination file system above
        SendToWs(ref, convertedHtml);
    },
    TaskContinuationOptions.AttachedToParent);
});

现在,几个注释:

>这是示例代码,所以我使用1MB缓冲区来读/写文件。这对HTML文件来说过多,浪费系统资源。您可以降低它以适应您的最大需求,或者将String读取/写入到StringBuilder中,这是我留下的一个练习,因为我会写大约500行代码来执行异步链接的读/写。 :P
>你会注意到,在读/写任务的继续我有TaskContinuationOptions.AttachedToParent。这是非常重要的,因为它将阻止Parallel :: ForEach的工作线程完成工作,直到所有的底层异步调用都完成。如果不在这里,您将同时启动所有5000个项目的工作,这将会对具有数千个计划任务的TPL子系统造成污染,并且根本不能正常扩展。
>我将SendToWs并发写入到文件共享文件中。我不知道SendToWs的实现是什么,但它也听起来像是做异步的好候选人。现在它被认为是纯粹的计算工作,因此在执行时将会刻录一个CPU线程。我把它作为一个练习,以确定如何最好地利用我所展示的内容来提高吞吐量。
>这是所有类型的自由格式,我的大脑是这里唯一的编译器,而SO的语法高光是我用来确保语法是好的。所以,请原谅任何语法错误,让我知道,如果我搞砸了太多的东西,你不能做头或尾巴,我会跟进。

翻译自:https://stackoverflow.com/questions/8505815/how-to-properly-parallelise-job-heavily-relying-on-i-o

转载注明原文:c# – 如何在很大程度上依赖于I/O来平衡工作