需要帮助跟踪线程冻结

Question

我正在使用此问题中描述的调用：跨线程/原子检查同步？

我需要创建一个任何线程都可以调用的方法调用程序，它将在执行过程中的特定给定点在主执行线程上执行。

我最终使用了 Invoker 类的实现： 我知道这在锁定方面可能不是最有效的，但理论上它的工作方式与 Thread.MemoryBarrier() 非常相似，例如 SLaks 建议的方式。

编辑：根据 MRAB 的建议。

public class Invoker
{
    private Queue<Action> Actions { get; set; }

    public Invoker()
    {
        this.Actions = new Queue<Action>();
    }

    public void Execute()
    {
        Console.WriteLine("Executing {0} actions on thread {1}", this.Actions.Count, Thread.CurrentThread.ManagedThreadId);

        while (this.Actions.Count > 0)
        {
            Action action;

            lock (this.Actions)
            {
                action = this.Actions.Dequeue();
            }

            action();
        }

        Console.WriteLine("Executed, {0} actions left", this.Actions.Count);
    }

    public void Invoke(Action action, bool block = true)
    {
        if (block)
        {
            Console.WriteLine("Invoking");
            SemaphoreSlim semaphore = new SemaphoreSlim(0, 1);

            lock (this.Actions)
            {
                this.Actions.Enqueue(delegate
                {
                    try
                    {
                        action();
                        Console.WriteLine("Actioned");
                    }
                    catch
                    {
                        Console.WriteLine("Exception thrown by action");
                        throw;
                    }
                    finally
                    {
                        semaphore.Release();
                        Console.WriteLine("Released");
                    }
                });
            }

            Console.WriteLine("Enqueued");

            Console.WriteLine("Waiting on thread {0}", Thread.CurrentThread.ManagedThreadId);
            semaphore.Wait();
            Console.WriteLine("Waited");
            semaphore.Dispose();
        }
        else
        {
            this.Actions.Enqueue(action);
        }
    }
}

许多 Console.WriteLine 可以帮助我跟踪我的冻结情况，无论此日志记录是否存在，这种情况都会发生（即，它们不对冻结负责，可以作为罪魁祸首而被丢弃）。

冻结发生在以下场景中：

1. 执行线程在循环中运行（调用Invoker.Execute）。
2. 在另外 2 个线程上，相对同时调用 2 个方法（调用 Invoker.Invoke）。
3. 第一个方法可以正常工作并被调用，但第二个方法在“等待”后（即 semaphore.Wait() 之后）冻结。

示例输出：

Executing 0 actions on thread 1
Executed, 0 actions left
Executing 0 actions on thread 1
Executed, 0 actions left
Invoking
Enqueued
Waiting on thread 7
Executing 1 actions on thread 1
Actioned
Released
Executed, 0 actions left
Waited
Invoking
Enqueued
Waiting on thread 8

我怀疑发生的情况是执行线程以某种方式阻塞，因此不执行第二个排队操作，并且不释放信号量（semaphore. Release())，从而不允许执行继续进行。

但这非常奇怪（在我看来），因为执行是在信号量阻塞之外的另一个线程上执行的，所以它不应该阻塞，对吗？

我试图构建一个测试用例来重现上下文环境中的问题，但我无法让它重现。我将其发布在这里作为我之前解释的 3 个步骤的说明。

static class Earth
{
    public const bool IsRound = true;
}

class Program
{
    static Invoker Invoker = new Invoker();

    static int i;

    static void TestInvokingThread()
    {
        Invoker.Invoke(delegate { Thread.Sleep(300); }); // Simulate some work
    }

    static void TestExecutingThread()
    {
        while (Earth.IsRound)
        {
            Thread.Sleep(100); // Simulate some work

            Invoker.Execute();

            Thread.Sleep(100); // Simulate some work
        }
    }

    static void Main(string[] args)
    {
        new Thread(TestExecutingThread).Start();

        Random random = new Random();

        Thread.Sleep(random.Next(3000)); // Enter at a random point

        new Thread(TestInvokingThread).Start();
        new Thread(TestInvokingThread).Start();
    }
}

输出（如预期发生的那样）：

Executing 0 actions on thread 12
Executed, 0 actions left
Executing 0 actions on thread 12
Executed, 0 actions left
Invoking
Enqueued
Waiting on thread 13
Invoking
Enqueued
Waiting on thread 14
Executing 2 actions on thread 12
Actioned
Released
Waited
Actioned
Released
Waited
Executed, 0 actions left
Executing 0 actions on thread 12
Executed, 0 actions left
Executing 0 actions on thread 12

实际问题：此时我要问的是，是否有经验丰富的线程程序员可以看到 Invoker 中的逻辑错误类可能永远使其阻塞，因为我认为不可能发生这种情况。同样，如果您可以说明一个使其阻塞的测试用例，我可能可以找到我的错误所在。 我不知道如何隔离问题。

注意：我很确定这并不是因为其特殊性而真正被视为质量问题，但我主要是发帖是绝望的求助，因为这是业余编程，我没有同事可以问。 经过一天的尝试和错误，我仍然无法修复它。

重要更新：我刚刚在第一次调用时也出现了这个错误，不一定只在第二。因此，它确实可以在调用者中自行冻结。但如何呢？在哪里？

Answer 1

我认为你应该在入队和出队时锁定操作。我偶尔会在这里遇到空引用异常：

this.Actions.Dequeue()();

可能是因为竞争条件。

我还认为排队的代码不应该处理信号量，而应该将其留给排队线程：

        Console.WriteLine("Invoking");
        SemaphoreSlim semaphore = new SemaphoreSlim(0, 1);

        this.Actions.Enqueue(delegate
        {
            action();
            Console.WriteLine("Actioned");
            semaphore.Release();
            Console.WriteLine("Released");
        });

        Console.WriteLine("Enqueued");

        Console.WriteLine("Waiting");
        semaphore.Wait();
        Console.WriteLine("Waited");
        semaphore.Dispose();

同样是因为竞争条件。

编辑：我想到，如果操作由于某种原因引发异常，信号量将不会被释放，所以：

                this.Actions.Enqueue(delegate
                {
                    try
                    {
                        action();
                        Console.WriteLine("Actioned");
                    }
                    catch
                    {
                        Console.WriteLine("Exception thrown by action");
                        throw;
                    }
                    finally
                    {
                        semaphore.Release();
                        Console.WriteLine("Released");
                    }
                });

这可能是问题所在吗？

编辑：修改时是否锁定 this.Actions ？

出队时：

            Action action;
            lock (this.Actions)
            {
                action = this.Actions.Dequeue();
            }
            action();

和入队时：

            lock (this.Actions)
            {
                this.Actions.Enqueue(delegate
                {
                    ...
                });
            }

Answer 2

知道了。这是我的程序中一个非常深的多层死锁，因此我无法轻松地重现它。不过，我会将 MRAB 的答案标记为已接受，因为它可能是由调用者本身引起的锁定的真正原因。