yield 在 lock 语句中返回

Question

如果我在锁定语句中有一个yield return，那么锁会在每个yield上被取出（在下面的示例中为5次），还是仅对列表中的所有项目取出一次锁？

谢谢

    private List<string> _data = new List<string>(){"1","2","3","4","5"};
    private object _locker =new object();
    public IEnumerable<string> GetData()
    {
        lock (_locker)
        {
            foreach (string s in _data)
            {
                yield return s;
            }
        }
    }

Answer 1

2022 年 10 月更新
时隔多年再读这个答案，感觉原来的语气太刺耳了，给人一种混蛋的感觉。所以我稍微软化了语气。

抱歉让这个死而复生，但是阅读了丹尼尔接受的答案，然后自己测试一下，我认为至少应该告知那些最初投票的 10 个人错误答案。丹尼尔后来回顾了这一点，并将他的答案更新到此处。

正确答案是：在每次yeald返回之间永远不会释放锁。
只有当枚举器完成时，即当 foreach 循环结束时，它才会被释放。

丹尼尔左转的地方是错误地搭建了测试脚手架。他的代码不是多线程的，并且总是以相同的方式进行计算。该代码中的锁仅获取一次，并且由于它是同一个线程，因此它始终是相同的锁。

我从 @Daniel 的答案中获取了代码，并将其更改为使用 2 个线程，一个用于 List1，另一个线程为 List2 的每次迭代创建。
注意：这不是此代码的结构方式，为了使代码更清晰、更易于阅读，请参阅@EZI 提供的社区 wiki。
然而，这确实提供了与丹尼尔的代码的直接比较，并且它充实了原始代码的问题。

正如您所看到的，一旦 t2 线程启动，线程就会死锁，因为 t2 正在等待一个永远不会被释放的锁。

代码：

void Main()
{
    object locker = new object();
    IEnumerable<string> myList0 = new DataGetter().GetData(locker, "List 0");
    IEnumerable<string> myList1 = new DataGetter().GetData(locker, "List 1");
    IEnumerable<string> myList2 = new DataGetter().GetData(locker, "List 2");

    Console.WriteLine("start Getdata");
    // Demonstrate that breaking out of a foreach loop releasees the lock
    var t0 = new Thread(() => {
        foreach( var s0 in myList0 )
        {
            Console.WriteLine("List 0 {0}", s0);
            if( s0 == "2" ) break;
        }
    });
    Console.WriteLine("start t0");
    t0.Start();
    t0.Join(); // Acts as 'wait for the thread to complete'
    Console.WriteLine("end t0");
    
    // t1's foreach loop will start (meaning previous t0's lock was cleared
    var t1 = new Thread(() => {
        foreach( var s1 in myList1)
        {
            Console.WriteLine("List 1 {0}", s1);
            // Once another thread will wait on the lock while t1's foreach
            // loop is still active a dead-lock will occure.
            var t2 = new Thread(() => {
                foreach( var s2 in myList2 )
                {
                    Console.WriteLine("List 2 {0}", s2);
                }
            } );
            Console.WriteLine("start t2");            
            t2.Start();
            t2.Join();
            Console.WriteLine("end t2");            
        }
    });
    Console.WriteLine("start t1");
    t1.Start();
    t1.Join();
    Console.WriteLine("end t1");
    Console.WriteLine("end GetData");
}

void foreachAction<T>( IEnumerable<T> target, Action<T> action )
{
    foreach( var t in target )
    {
        action(t);
    }
}

public class DataGetter
{
    private List<string> _data = new List<string>() { "1", "2", "3", "4", "5" };
    
    public IEnumerable<string> GetData(object lockObj, string listName)
    {
        Console.WriteLine("{0} Starts", listName);
        lock (lockObj)
        {
            Console.WriteLine("{0} Lock Taken", listName);
            foreach (string s in _data)
            {
                yield return s;
            }
        }
        Console.WriteLine("{0} Lock Released", listName);
    }
}

Answer 2

@Lockszmith 有一个很好的收获（+1）。我只是发布这个，因为我发现他的代码很难阅读。这是一个“社区维基”。随时更新。

object lockObj = new object();

Task.Factory.StartNew((_) =>
{
    System.Diagnostics.Debug.WriteLine("Task1 started");
    var l1 = GetData(lockObj, new[] { 1, 2, 3, 4, 5, 6, 7, 8 }).ToList();
}, TaskContinuationOptions.LongRunning);

Task.Factory.StartNew((_) =>
{
    System.Diagnostics.Debug.WriteLine("Task2 started");
    var l2 = GetData(lockObj, new[] { 10, 20, 30, 40, 50, 60, 70, 80 }).ToList();
}, TaskContinuationOptions.LongRunning);

---

public IEnumerable<T> GetData<T>(object lockObj, IEnumerable<T> list)
{
    lock (lockObj)
    {
        foreach (T x in list)
        {
            System.Diagnostics.Debug.WriteLine("Thread " + Thread.CurrentThread.ManagedThreadId + " returned "  + x );
            Thread.Sleep(1000);
            yield return x;
        }
    }
}