Question

我有一个C＃线程池类，它基于https://stackoverflow.com/a/1656662/782181的生产者/消费者代码。注意：我这样做而不是使用BlockingCollection，因为我坚持使用.NET2.0！

我在类中添加了一个函数，可以从主线程调用，以允许主线程做一些工作。我的想法是，在某些时候，主线程等待工作完成，但是我可以让主线程做一些工作来加快速度。

这是一个精简版的课程，用于演示：

public static class SGThreadPool
{
    // Shared object to lock access to the queue between threads.
    private static object locker = new object();

    // The various threads that are doing our work.
    private static List<Thread> workers = null;

    // A queue of tasks to be completed by the workers.
    private static Queue<object> taskQueue = new Queue<object>();
    private static Queue<WaitCallback> taskCallbacks = new Queue<WaitCallback>();

    //OMMITTED: Init function (starts threads)

    // Enqueues a task for a thread to do.
    public static void EnqueueTask(WaitCallback callback, object context)
    {
        lock(locker)
        {
            taskQueue.Enqueue(context);
            taskCallbacks.Enqueue(callback);
            Monitor.PulseAll(locker); //Q: should I just use 'Pulse' here?
        }
    }

    // Can be called from main thread to have it "help out" with tasks.
    public static bool PerformTask()
    {
        WaitCallback taskCallback = null;
        object task = null;
        lock(locker)
        {
            if(taskQueue.Count > 0)
            {
                task = taskQueue.Dequeue();
            }
            if(taskCallbacks.Count > 0)
            {
                taskCallback = taskCallbacks.Dequeue();
            }
        }

        // No task means no work, return false.
        if(task == null || taskCallback == null) { return false; }

        // Do the work!
        taskCallback(task);
        return true;
    }

    private static void Consume()
    {
        while(true)
        {
            WaitCallback taskCallback = null;
            object task = null;
            lock(locker)
            {
                // While no tasks in the queue, wait.
                while(taskQueue.Count == 0)
                {
                    Monitor.Wait(locker);
                }

                // Get a task.
                task = taskQueue.Dequeue();
                taskCallback = taskCallbacks.Dequeue();
            }

            // Null task signals an exit.
            if(task == null || taskCallback == null) { return; }

            // Call consume callback with task as context.
            taskCallback(task);
        }
    }
}

基本上，我可以将后台线程要执行的许多任务排入队列。但是主线程也可以通过调用PerformTask（）来执行任务并执行它。

我遇到了一个不常见的问题，即主线程会尝试锁定＆＃34;在PerformTask（）中，但已经锁定了。主线程等待，但由于某种原因锁定无法使用。

代码中没有任何东西可以作为导致死锁的问题跳出来 - 我希望其他人可能能够发现问题。我已经看了几个小时了，而且我不确定为什么主线会卡在＆＃34; lock（）＆＃34;在PerformTask（）中调用。似乎没有其他线程会无限期地持有锁？允许主线程以这种方式与池交互是一个坏主意吗？

Answer 1

嗯，所以，虽然我仍然想知道为什么上面的代码在某些情况下可能会死锁，但我想我找到了一个可以解决这个问题的解决方法。

如果主线程将在这里工作，我想确保主线程不会长时间被阻塞。毕竟，一般的开发规则：不要阻止主线程！

所以，我正在尝试的解决方案是直接使用Monitor.TryEnter，而不是使用lock（）作为主线程。这允许我指定主线程愿意等待锁定多长时间的超时。

public static bool PerformTask()
{
    WaitCallback taskCallback = null;
    object task = null;

    // Use TryEnter, rather than "lock" because 
    // it allows us to specify a timeout as a failsafe.
    if(Monitor.TryEnter(locker, 500))
    {
        try 
        {
            // Pull a task from the queue.
            if(taskQueue.Count > 0)
            {
                task = taskQueue.Dequeue();
            }
            if(taskCallbacks.Count > 0)
            {
                taskCallback = taskCallbacks.Dequeue();
            }
        }
        finally
        {
            Monitor.Exit(locker);
        }
    }

    // No task means no work, return false.
    if(task == null || taskCallback == null) { return false; }

    // Do the work!
    taskCallback(task);
    return true;
}

在此代码中，线程将等待获取最长500ms的锁定。如果不能出于任何原因，它无法完成任何任务，但至少它不会卡住。将主线程置于无限期等待的位置似乎是一个好主意。

我相信当你使用lock（）时，编译器会生成类似的代码，所以我不认为这个解决方案会有任何性能问题。

具有主线程支持的生产者/消费者线程池 - 偶发死锁？

1 个答案: