标签: parallel-extensions

下面的代码片段有什么区别？两个都不会使用线程池线程吗？

例如,如果我想为集合中的每个项目调用一个函数,

Parallel.ForEach<Item>(items, item => DoSomething(item));

vs

foreach(var item in items)
{
  Task.Factory.StartNew(() => DoSomething(item));
}

这个班级CancellationTokenSource是一次性的.快速浏览Reflector证明KernelEvent了(很可能)非托管资源的使用.由于CancellationTokenSource没有终结器,如果我们不处理它,GC将不会这样做.

另一方面,如果您查看MSDN文章" 托管线程中的取消"中列出的示例,则只有一个代码段处置该令牌.

在代码中处理它的正确方法是什么？

1. using如果您不等待它,则无法将启动并行任务的代码包装起来.只有在你不等的时候取消才有意义.
2. 当然你可以ContinueWith通过Dispose电话添加任务,但这是要走的路吗？
3. 那些可以取消同步的可取消的PLINQ查询呢,但最后只做一些事情？我们说吧.ForAll(x => Console.Write(x))？
4. 它可以重复使用吗？是否可以将相同的令牌用于多个调用,然后将其与主机组件一起处理,让我们说UI控件？

因为它没有类似于Reset清理IsCancelRequested和Token字段的方法,所以我认为它不可重复使用,因此每次启动任务(或PLINQ查询)时都应该创建一个新任务.这是真的吗？如果是,我的问题是Dispose在这些CancellationTokenSource案例中处理的正确和建议的策略是什么？

在我的一个有点聚合的项目中,我从网上解析了feed,podcast等.

如果我使用顺序方法,考虑到大量资源,处理所有资源需要相当长的时间(因为网络问题和类似的东西);

foreach(feed in feeds)
{
   read_from_web(feed)
   parse(feed)
}

所以我想实现并发,并且无法决定我是否应该使用ThreadPools来处理工作线程,或者只是依靠TPL来对它进行排序.

ThreadPools肯定会用工作线程处理我的工作,我会得到我所期望的(在多核CPU环境中,其他核心也将被利用).

但我仍然想考虑TPL,因为它推荐的方法,但我有点担心它.首先,我知道TPL使用ThreadPools,但增加了额外的决策层.我主要关心的是单核环境存在的情况.如果我没错,TPL从一开始就用一个数量的工作线程开始,这些工作线程数等于可用的CPU核心数.我担心TPL会产生与我的IO绑定案例的顺序方法类似的结果.

因此,对于IO绑定操作(在我的情况下从Web读取资源),最好是使用ThreadPools来控制事物,还是更好地依赖于TPL？TPL也可以用于IO绑定场景吗？

更新:我主要担心的是 - 在单核CPU环境中,TPL只是表现得像顺序方式,还是会提供并发性？我已经阅读了使用Microsoft .NET的并行编程,所以这本书却找不到确切的答案.

注意:这是我之前的问题的重新措辞[ 是否可以将线程并发和并行一起使用？这是错误的措辞.

至少从.NET 4.0发布以来,微软似乎已经付出了很多努力来支持并行和异步编程,而且似乎已经出现了很多API和库.特别是最近随处可见的以下花哨的名字:

• 反应性框架,
• PLINQ(并行LINQ),
• TPL(任务并行库)和
• 并行扩展.

现在它们似乎都是微软的产品,它们似乎都针对.NET的异步或并行编程场景.但目前尚不清楚它们实际上是什么以及它们如何相互关联.实际上有些可能是同一件事.

简而言之,任何人都可以直接记录什么是什么？

我正在使用Parallel.ForEach并且我正在做一些数据库更新,现在没有设置MaxDegreeOfParallelism,双核处理器机器导致sql客户端超时,否则四核处理器机器不知何故不会超时.

现在我无法控制我的代码运行的哪种处理器内核可用,但是我可以使用MaxDegreeOfParallelism更改某些设置,这些设置可能会同时运行较少的操作而不会导致超时？

我可以增加超时但它不是一个好的解决方案,如果在较低的CPU上我可以同时处理较少的操作,这将减少对CPU的负载.

好的我也读过所有其他帖子和MSDN,但是将MaxDegreeOfParallelism设置为较低值会让我的四核机器遭受损失吗？

例如,无论如何,如果CPU有两个内核,那么使用20,如果CPU有四个内核,那么40？

我有一个关于并行循环的问题.我有以下代码:

    public static void MultiplicateArray(double[] array, double factor)
    {
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = array[i] * factor;
        }
    }

    public static void MultiplicateArray(double[] arrayToChange, double[] multiplication)
    {
        for (int i = 0; i < arrayToChange.Length; i++)
        {
            arrayToChange[i] = arrayToChange[i] * multiplication[i];
        }
    }

    public static void MultiplicateArray(double[] arrayToChange, double[,] multiArray, int dimension)
    {
        for (int i = 0; i < arrayToChange.Length; i++)
        {
            arrayToChange[i] = arrayToChange[i] * multiArray[i, dimension];
        }
    }

现在我尝试添加并行功能: …

例如:

ConcurrentDictionary<string,Payload> itemCache = GetItems();

foreach(KeyValuePair<string,Payload> kvPair in itemCache)
{
    if(TestItemExpiry(kvPair.Value))
    {   // Remove expired item.
        Payload removedItem;
        itemCache.TryRemove(kvPair.Key, out removedItem);
    }
}

显然,对于普通的Dictionary,这将引发异常,因为删除项会在枚举的生命周期中更改字典的内部状态.我的理解是,并非ConcurrentDictionary的情况,因为提供的IEnumerable处理内部状态更改.我明白了吗？有更好的模式可供使用吗？

我使用以下代码

var processed = new List<Guid>();
Parallel.ForEach(items, item => 
{
    processed.Add(SomeProcessingFunc(item));
});

上面的代码线程是否安全？处理后的列表是否有可能被破坏？或者我应该在添加之前使用锁？

var processed = new List<Guid>();
Parallel.ForEach(items, item => 
{
    lock(items.SyncRoot)
        processed.Add(SomeProcessingFunc(item));
});

谢谢.

我正在寻找C#中的并行化(多线程)排序算法的简单实现,它可以在List<T>Arrays上运行,也可能使用Parallel Extensions,但这部分并不是绝对必要的.

编辑:Frank Krueger提供了一个很好的答案,但我希望将该示例转换为不使用LINQ的示例.还要注意,Parallel.Do()似乎已被取代了Parallel.Invoke().

谢谢.

static async void Main(string[] args)
{
    Task t = new Task(() => { throw new Exception(); });

    try
    {                
        t.Start();
        t.Wait();                
    }
    catch (AggregateException e)
    {
        // When waiting on the task, an AggregateException is thrown.
    }

    try
    {                
        t.Start();
        await t;
    }
    catch (Exception e)
    {
        // When awating on the task, the exception itself is thrown.  
        // in this case a regular Exception.
    }           
}

在TPL中,当在Task中抛出异常时,它被包装为AggregateException.
但是使用await关键字时也不会发生同样的情况.
这种行为的解释是什么？