.Net4.0 Parallel编程（一）Data Parallelism 上_转

最新推荐文章于 2024-06-24 20:08:43 发布

weixin_30781631

最新推荐文章于 2024-06-24 20:08:43 发布

阅读量48

点赞数

原文链接：http://www.cnblogs.com/timy/archive/2010/08/28/1811158.html

版权

现在已经进入了多核的时代，我们的程序如何更多的利用好cpu，答案是并行处理。在.net4.0之前我们要开发并行的程序是非常的困难，在.net4.0中，在命名空间System.Threading.Tasks提供了方便的并行开发的类库。本文中主要看看Data Parallel，

看看并行的For、Foreach。

Parallel.For

首先先写一个普通的循环：

 
    01. 
    private void NormalFor()  
   
    02. 
    {  
   
    03. 
        for (var i = 0; i < 10000; i++)  
   
    04. 
        {  
   
    05. 
            for (var j = 0; j < 1000; j++)  
   
    06. 
            {  
   
    07. 
                for (var k = 0; k < 100; k++)  
   
    08. 
                {  
   
    09. 
                    DoSomething();  
   
    10. 
                }  
   
    11. 
            }  
   
    12. 
        }  
   
    13. 
    }

再看一个并行的For语句：

 
    01. 
    private void ParallelFor()  
   
    02. 
    {  
   
    03. 
        Parallel.For(0, 10000, i =>  
   
    04. 
        {  
   
    05. 
            for (int j = 0; j < 1000; j++)  
   
    06. 
            {  
   
    07. 
                for (var k = 0; k < 100; k++)  
   
    08. 
                {  
   
    09. 
                    DoSomething();  
   
    10. 
                }  
   
    11. 
            }  
   
    12. 
        });  
   
    13. 
    }

看下测试方法：

 
    01. 
    [TestMethod()]  
   
    02. 
    public void TestForLoop()   
   
    03. 
    {  
   
    04. 
        _StopWatch.Start();  
   
    05. 
        this.NormalFor();  
   
    06. 
        _StopWatch.Stop();  
   
    07. 
        Console.WriteLine("NormalForLoop Runned Time:{0}", _StopWatch.ElapsedMilliseconds);  
   
    08. 
        _StopWatch.Reset();  
   
    09. 
        _StopWatch.Start();  
   
    10. 
        this.ParallelFor();  
   
    11. 
        _StopWatch.Stop();  
   
    12. 
        Console.WriteLine("Parallel Loop:{0}", _StopWatch.ElapsedMilliseconds);  
   
    13. 
    }

测试结果：

上面的例子中，只是将最外层的For语句替换成了Parallel.For，我们可以看到Parallel执行速度提高了近一倍。下面我把里面的循环也改成并行的：

 
    01. 
    private void ParallelNestedFor()  
   
    02. 
    {  
   
    03. 
        Parallel.For(0, 10000, i =>  
   
    04. 
        {  
   
    05. 
            Parallel.For(0, 1000, j =>  
   
    06. 
            {  
   
    07. 
                for (var k = 0; k < 100; k++)  
   
    08. 
                {  
   
    09. 
                    DoSomething();  
   
    10. 
                }  
   
    11. 
            });  
   
    12. 
        });  
   
    13. 
    }

结果：

也许会令我们感到惊讶的是：嵌套Paralled For之后速度并没有更快，反而稍微慢了。其实是这样的，因为我们的示例中大部分操作是在最外层循环，而在并行操作中会需要缓存数据等会浪费一定的性能。当我们把最外层的循环调整成100，中间层为10000时，我们来看下结果：

所以，是否需要嵌套的时候，需要我们根据一些实际情况来决定，不过对于大部分操作，最外层的并行处理已经足够了。

Parallel.ForEach

我们来看两段很简单的代码：

 
    01. 
    private void NormalForeach()   
   
    02. 
    {  
   
    03. 
        foreach (var file in GetFiles())  
   
    04. 
        {  
   
    05. 
            DoSomething();  
   
    06. 
        }  
   
    07. 
           
    08. 
    }  
   
    09. 
    private void ParallelForeach()  
   
    10. 
    {  
   
    11. 
        Parallel.ForEach(GetFiles(), file => {  
   
    12. 
            DoSomething();  
   
    13. 
        });  
   
    14. 
    }