C# 我的GetEnumerator是否导致死锁？

我开始编写我的第一个并行应用程序。此分区器将枚举

IDataReader

一次从数据源提取

chunkSize

记录

TLDR；版本

private object _Lock = new object();
public IEnumerator GetEnumerator()
{
    var infoSource = myInforSource.GetEnumerator();
                   //Will this cause a deadlock if two threads 
    lock (_Lock)   //use the enumator at the same time?
    {
        while (infoSource.MoveNext())
        {
            yield return infoSource.Current;
        }
    }
}

完整代码

protected class DataSourcePartitioner<object[]> : System.Collections.Concurrent.Partitioner<object[]>
{
    private readonly System.Data.IDataReader _Input;
    private readonly int _ChunkSize;
    public DataSourcePartitioner(System.Data.IDataReader input, int chunkSize = 10000)
        : base()
    {
        if (chunkSize < 1)
            throw new ArgumentOutOfRangeException("chunkSize");
        _Input = input;
        _ChunkSize = chunkSize;
    }

    public override bool SupportsDynamicPartitions { get { return true; } }

    public override IList<IEnumerator<object[]>> GetPartitions(int partitionCount)
    {

        var dynamicPartitions = GetDynamicPartitions();
        var partitions =
            new IEnumerator<object[]>[partitionCount];

        for (int i = 0; i < partitionCount; i++)
        {
            partitions[i] = dynamicPartitions.GetEnumerator();
        }
        return partitions;


    }

    public override IEnumerable<object[]> GetDynamicPartitions()
    {
        return new ListDynamicPartitions(_Input, _ChunkSize);
    }
    private class ListDynamicPartitions : IEnumerable<object[]>
    {
        private System.Data.IDataReader _Input;
        int _ChunkSize;
        private object _ChunkLock = new object();
        public ListDynamicPartitions(System.Data.IDataReader input, int chunkSize)
        {
            _Input = input;
            _ChunkSize = chunkSize;
        }

        public IEnumerator<object[]> GetEnumerator()
        {

            while (true)
            {
                List<object[]> chunk = new List<object[]>(_ChunkSize);
                lock(_Input)
                {
                    for (int i = 0; i < _ChunkSize; ++i)
                    {
                        if (!_Input.Read())
                            break;
                        var values = new object[_Input.FieldCount];
                        _Input.GetValues(values);
                        chunk.Add(values);
                    }
                    if (chunk.Count == 0)
                        yield break;
                }
                var chunkEnumerator = chunk.GetEnumerator();
                lock(_ChunkLock) //Will this cause a deadlock?
                {
                    while (chunkEnumerator.MoveNext())
                    {
                        yield return chunkEnumerator.Current;
                    }
                }
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable<object[]>)this).GetEnumerator();
        }
    }
}

受保护类DataSourcePartitioner:System.Collections.Concurrent.Partitioner
{
专用只读System.Data.IDataReader\u输入；
私有只读int_ChunkSize；
公共DataSourcePartitioner（System.Data.IDataReader输入，int chunkSize=10000）
：base（）
{
if（chunkSize<1）
抛出新ArgumentOutOfRangeException（“chunkSize”）；
_输入=输入；
_ChunkSize=ChunkSize；
}
公共覆盖布尔支持动态分区{get{return true；}}
公共覆盖IList GetPartitions（int partitionCount）
{
var dynamicPartitions=GetDynamicPartitions（）；
var分区=
新的IEnumerator[分区计数]；
对于（int i=0；i

我想要它传回的

IEnumerable

对象是线程安全的（我假设PLINQ和TPL可能需要它），底部附近

\u ChunkLock

上的锁是否有助于提供线程安全，还是会导致死锁？从文档中，我无法判断是否会在

yeld返回时释放锁

另外，如果.net有内置的功能，可以完成我想做的事情，我宁愿使用它。如果您在代码中发现任何其他问题，我将不胜感激。
我编写了一个测试框架，它不会死锁，但第二个线程将永远不会获得数据

static void Main()
{
    En en = new En();
    Task.Factory.StartNew(() =>
        {
            foreach (int i in en)
            {
                Thread.Sleep(100);
                Console.WriteLine("A:" + i.ToString());
            }
        });
    Task.Factory.StartNew(() =>
    {
        foreach (int i in en)
        {
            Thread.Sleep(10);
            Console.WriteLine("B:" +i.ToString());
        }
    });
    Console.ReadLine();
}

public class En : IEnumerable
{
    object _lock = new object();
    static int i = 0;
    public IEnumerator GetEnumerator()
    {
        lock (_lock)
        {
            while (true)
            {
                if (i < 10)
                    yield return i++;
                else
                    yield break;
            }
        }
    }
}

下面是一个更新版本的
GetEnumerator
，应该可以正常工作

public IEnumerator<object[]> GetEnumerator()
{

    while (true)
    {
        List<object[]> chunk = new List<object[]>(_ChunkSize);
        _ChunkPos = 0;
        lock(_Input)
        {
            for (int i = 0; i < _ChunkSize; ++i)
            {
                if (!_Input.Read())
                    break;
                var values = new object[_Input.FieldCount];
                _Input.GetValues(values);
                chunk.Add(values);
            }
            if (chunk.Count == 0)
                yield break;
        }
        var chunkEnumerator = chunk.GetEnumerator();
        while (true)
        {
            object[] retVal;
            lock (_ChunkLock)
            {
                if (chunkEnumerator.MoveNext())
                {
                    retVal = chunkEnumerator.Current;
                }
                else 
                    break; //break out of chunk while loop.
            }
            yield return retVal;
        }
    }
}

public IEnumerator GetEnumerator（）
{
while（true）
{
列表块=新列表（\u ChunkSize）；
_ChunkPos=0；
锁定（_输入）
{
对于（int i=0；i<\u ChunkSize；++i）
{
如果（！\u Input.Read（））
打破
var值=新对象[_Input.FieldCount]；
_输入.GetValues（值）；
添加（值）；
}
如果（chunk.Count==0）
屈服断裂；
}
var chunkEnumerator=chunk.GetEnumerator（）；
while（true）
{
对象[]返回；
锁（_ChunkLock）
{
if（chunkEnumerator.MoveNext（））
{
retVal=chunkEnumerator.Current；
}
其他的
break；//在循环时断开块。
}
收益回报率；
}
}
}
一句话：也许*

如果您总是在
foreach
循环的上下文中使用此代码，那么您就不太可能遇到死锁（除非您的
myInfoSource
可能是无限的，或者您的
foreach
循环中有一些永远不会终止的代码），尽管您可能会看到速度变慢

潜在（实际上，保证）死锁的更可能原因是：

var myObject = new YourObject();
var enumerator = myObject.GetEnumerator();

// if you do this, and then forget about it...
enumerator.MoveNext();

// ...your lock will never be released

*我是根据你最初的代码块来回答这个问题的

var myObject = new YourObject();
var enumerator = myObject.GetEnumerator();

// if you do this, and then forget about it...
enumerator.MoveNext();

// ...your lock will never be released