用法示例

假设我要创建10个线程，打开10个文件：1.txt，2.txt，3.txt ... 10.txt并随机向这些文件写入500 000个后续数字。

我可以这样做：

ConcurrentQueue<int> objs = new ConcurrentQueue<int>(); // 500000 numbers go here
Task[] tasks = Enumerable.Range(1, 10)
    .Select(i =>
    {
        return Task.Factory.StartNew(() => 
        {
            using (var f = File.Open($"{i}.txt"))
            {
                using (var wr = StreamWriter(f))
                {
                    while (objs.TryDequeue(out int obj))
                    {
                        wr.WriteLine(obj);
                    }
                }
            }
        }
    })
    .ToArray();
Task.WaitAll(tasks);

但是，是否可以在不使用并发集合的情况下提供相同的行为，只需使用TPL？

Answer 1

如果删除了除最后两个编辑之外的所有内容，那会更好。

如果问题是Can you pass an object per task (not thread) when using Parallel.？答案是：是的，您可以通过any of the overloads接受本地州，即TLocal类型this one：

public static ParallelLoopResult ForEach<TSource, TLocal>(
    IEnumerable<TSource> source,
    Func<TLocal> localInit,
    Func<TSource, ParallelLoopState, TLocal, TLocal> body,
    Action<TLocal> localFinally
)

Parallel.For不使用线程。它对数据进行分区，并为每个分区创建一个任务。每个任务最终都会处理所有分区的数据。通常，Parallel使用与核心一样多的任务。它还使用当前线程进行处理，这就是它似乎阻止当前线程的原因。它没有，它开始用于处理其中一个分区。

处理本地数据的函数允许您生成初始本地值并将其传递给每个body调用。所有带有本地数据的重载都需要body重新调整（可能已修改的）数据，因此Parallel本身不会必须存储它。这是必不可少的，因为Parallel.可以终止并重新启动任务。如果必须跟踪本地数据，它将无法轻松或有效地完成这项工作。

对于这个特定示例，并且绕过ORM不适合批量操作的事实，尤其是在处理数十万个对象时，localInit应该创建一个新会话。 body应该使用并返回该会话，最后localFinally应该处置它。

var mySessionFactory
var myData=....;
Parallel.ForEach(
    myData,
    ()=>CreateSession(),
    (record,state,session)=>{
        //process the data etc.
        return session;
    },
    (session)=>session.Dispose()
);

但是还有一些警告。 NH会保留内存中的更改，直到刷新并清除缓存为止。这将产生内存问题。一种解决方案是定期计数和刷新数据。状态可以是(int counter,Session session) tupple：

，而不是会话

Parallel.ForEach(
    myData,
    ()=>(counter:0,session:CreateSession()),
    (record,state,localData)=>{
        var (counter,session)=localData;
        //process the data etc.
        if (counter % 1000 ==0)
        {
            session.Flush();
            session.Clear();
        }
        return (++counter,session);
    },
    data=>data.session.Dispose()
);

更好的解决方案是提前批处理对象，这样循环就可以在IEnumerable<MyRecord>数组上运行而不是IEnumerable<MyRecord[]>。与批量语句相结合，这将减少ORM对批量操作施加的性能损失。

编写Batch方法并不难，但MoreLinq已经提供了一个，可用作源代码或NuGet包：

var myBatches=myData.Batch(1000);
Parallel.ForEach(
    myBatches,
    ()=>CreateSession(),
    (records,state,session)=>{

        foreach(var record in records)
        {
            //process the data etc.
            session.Save(record);                
        }
        session.Flush();
        session.Clear();
        return session;
    },
    data=>data.session.Dispose()
);

Answer 2

不，没有。

最接近的解决方案是手动创建N个线程（使用Task或Parallel.For / Parallel.ForEach）并使用ConcurrentQueue线程安全地分发数据。

TPL Parallel.ForEach中的每线程实例对象

用法示例

2 个答案: