Question

本周早些时候在Stackoverflow上获得了一些帮助，这导致了一个生产者/消费者模式，用于加载处理和将大型数据集导入RavenDb。 Parallelization of CPU bound task continuing with IO bound

我现在正在寻求限制生产者提前准备的工作单位数量，以便管理内存消耗。我已经使用基本信号量实现了限制，但是我在某个时刻遇到了实现死锁问题。

我无法弄清楚导致死锁的原因。以下是代码的摘录：

private static void LoadData<TParsedData, TData>(IDataLoader<TParsedData> dataLoader, int batchSize, Action<IndexedBatch<TData>> importProceedure, Func<IEnumerable<TParsedData>, List<TData>> processProceedure)
    where TParsedData : class
    where TData : class
{
    Console.WriteLine(@"Loading {0}...", typeof(TData).ToString());

    var batchCounter = 0;

    var ist = Stopwatch.StartNew();

    var throttler = new SemaphoreSlim(10);
    var bc = new BlockingCollection<IndexedBatch<TData>>();
    var importTask = Task.Run(() =>
    {
        bc.GetConsumingEnumerable()
            .AsParallel()
            .WithExecutionMode(ParallelExecutionMode.ForceParallelism)
            //or
            //.WithDegreeOfParallelism(1)
            .WithMergeOptions(ParallelMergeOptions.NotBuffered)
            .ForAll(data =>
            {
                var st = Stopwatch.StartNew();
                importProceedure(data);

                Console.WriteLine(@"Batch imported {0} in {1} ms", data.Index, st.ElapsedMilliseconds);
                throttler.Release();
            });
    });
    var processTask = Task.Run(() =>
    {
        dataLoader.GetParsedItems()
            .Partition(batchSize)
            .AsParallel()
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            //or
            //.WithDegreeOfParallelism(1)
            .WithMergeOptions(ParallelMergeOptions.NotBuffered)
            .ForAll(batch =>
            {
                throttler.Wait(); //.WaitAsync()
                var batchno = ++batchCounter;
                var st = Stopwatch.StartNew();

                bc.Add(new IndexedBatch<TData>(batchno, processProceedure(batch)));

                Console.WriteLine(@"Batch processed {0} in {1} ms", batchno, st.ElapsedMilliseconds);
            });
    });

    processTask.Wait();
    bc.CompleteAdding();
    importTask.Wait();

    Console.WriteLine(nl(1) + @"Loading {0} completed in {1} ms", typeof(TData).ToString(), ist.ElapsedMilliseconds);
}

public class IndexedBatch<TBatch> 
    where TBatch : class
{
    public IndexedBatch(int index, List<TBatch> batch)
    {
        Index = index;
        Batch = batch ?? new List<TBatch>();
    }

    public int Index { get; set; }
    public List<TBatch> Batch { get; set; }
}

这是对LoadData的调用：

LoadData<DataBase, Data>(
    DataLoaderFactory.Create<DataBase>(datafilePath),
    1024,
    (data) =>
    {
        using (var session = Store.OpenSession())
        {
            foreach (var i in data.Batch)
            {
                session.Store(i);
                d.TryAdd(i.LongId.GetHashCode(), int.Parse(i.Id.Substring(i.Id.LastIndexOf('/') + 1)));
            }
            session.SaveChanges();
        }
    },
    (batch) =>
    {
        return batch.Select(i => new Data()
        {
            ...
        }).ToList();
    }
);

Store是RavenDb IDocumentStore。 DataLoaderFactory为给定数据集构造自定义解析器。

Answer 1

很难调试死锁而没有大箭头说“块在这里！”。避免在没有调试器的情况下调试代码：BlockingCollection已经可以节制。使用带有int boundedCapacity参数的the constructor并消除信号量。非常高的赔率可以解决你的僵局。

Answer 2

你能检查一下你拥有的线程数量吗？可能你因为阻塞而耗尽了线程池。如果TPL认为你的代码在没有它们的情况下会死锁，那么TPL会注入比ProcessorCount更多的线程。但它只能达到一定限度。

无论如何，阻止TPL任务内部通常是一个坏主意，因为内置启发式方法最适用于非阻塞内容。

限制生产者/消费者模式导致僵局

2 个答案: