c# - 协助 UI Dispatcher 处理大量的方法调用

Question

下面的帖子比预期的要长一些 * 我为此道歉，但也许你会觉得读起来很有趣，也许你有想法可以帮助我:)

我正在开发一个小应用程序，它的 GUI 由许多 List 控件组成。每个 List 控件都有一个与之关联的线程 永久生产正在添加到列表中的字符串。

为了允许不同的线程更新 List 控件，我构建了一个扩展的 ObservableCollection，它异步调用它的所有操作到 UI 调度程序，它工作得非常好。这是该类的代码片段，用于举例说明插入操作:

public class ThreadSaveObservableCollection<T> : ObservableCollection<T> {

    private int _index;

    private Dispatcher _uiDispatcher;
    private ReaderWriterLock _rwLock;

    // ...

    private bool _insertRegFlag;

    new public void Insert (int index, T item) {

        if (Thread.CurrentThread == _uiDispatcher.Thread) {

            insert_(index, item);
        } else {

            if (_insertRegFlag) { }
            else {

                BufferedInvoker.RegisterMethod(_index + "." + (int)Methods.Insert);
                _insertRegFlag = true;
            }

            BufferedInvoker.AddInvocation(new Invocation<int, T> { Ident = _index + "." + (int)Methods.Insert, Dispatcher = _uiDispatcher, Priority = DispatcherPriority.Normal, Param1 = index, Param2 = item, Method = new Action<int, T>(insert_) });
        }
    }

    private void insert_ (int index, T item) {

        _rwLock.AcquireWriterLock(Timeout.Infinite);

        DateTime timeStampA = DateTime.Now;

        base.Insert(index, item);

        DateTime timeStampB = DateTime.Now;

        BufferedInvoker.Returned(_index + "." + (int)Methods.Insert, timeStampB.Subtract(timeStampA).TotalMilliseconds);

        _rwLock.ReleaseWriterLock();
    }

    // ...
}

为了以一种挂起的调用任务的形式对调用进行建模，我构建了以下内容:

public interface IInvocation {

    string Ident { get; set; }
    void Invoke ();
}

public struct Invocation : IInvocation {

    public string Ident { get; set; }
    public Dispatcher Dispatcher { get; set; }
    public DispatcherPriority Priority { get; set; }
    public Delegate Method { get; set; }

    public void Invoke () {

        Dispatcher.BeginInvoke(Method, Priority, new object[] { });
    }
}

我现在的问题是因为 巨额我在 UI 调度程序上调用的方法调用(我有大约 8 到 10 个线程，这些线程永久地生成它们添加到列表中的字符串)我的 UI 失去响应用户 I/O 的能力(例如使用鼠标)大约30 秒，直到大约一分钟后它根本不接受任何用户交互。

为了面对这个问题，我写了一些 缓冲调用程序 它负责缓冲我想调用到 UI 调度程序的所有方法调用，然后在 中调用它们。受控方式例如在对 的调用之间有一些延迟避免洪水 UI 调度程序。

下面是一些代码来说明我在做什么(请参阅代码段后面的描述):

public static class BufferedInvoker {

    private static long _invoked;
    private static long _returned;
    private static long _pending;
    private static bool _isInbalanced;

    private static List<IInvocation> _workLoad;
    private static Queue<IInvocation> _queue;

    private static Thread _enqueuingThread;
    private static Thread _dequeuingThread;
    private static ManualResetEvent _terminateSignal;
    private static ManualResetEvent _enqueuSignal;
    private static ManualResetEvent _dequeueSignal;

    public static void AddInvocation (IInvocation invocation) {

        lock (_workLoad) {

            _workLoad.Add(invocation);
            _enqueuSignal.Set();
        }
    }

    private static void _enqueuing () {

        while (!_terminateSignal.WaitOne(0, false)) {

            if (_enqueuSignal.WaitOne()) {

                lock (_workLoad) {

                    lock (_queue) {

                        if (_workLoad.Count == 0 || _queue.Count == 20) {

                            _enqueuSignal.Reset();
                            continue;
                        }

                        IInvocation item = _workLoad[0];
                        _workLoad.RemoveAt(0);
                        _queue.Enqueue(item);

                        if (_queue.Count == 1) _dequeueSignal.Set();
                    }
                }
            }
        }
    }

    private static void _dequeuing () {

        while (!_terminateSignal.WaitOne(0, false)) {

            if (_dequeueSignal.WaitOne()) {

                lock (_queue) {

                    if (_queue.Count == 0) {

                        _dequeueSignal.Reset();
                        continue;
                    }

                    Thread.Sleep(delay);

                    IInvocation i = _queue.Dequeue();
                    i.Invoke();

                    _invoked++;
                    _waiting = _triggered - _invoked;
                }
            }
        }
    }

    public static void Returned (string ident, double duration) {

        _returned++;

        // ...
    }
}

这背后的想法 缓冲调用者 是 ObservableCollections 不要自己调用操作，而是调用 添加调用 的方法缓冲调用者 它将调用任务放入其 _工作量列表。 缓冲调用者 然后维护两个在 上运行的“内部”线程_队列 - 一个线程从 获取调用_工作量列出并将它们放入 _队列另一个线程将调用置于 之外_队列最后一个接一个地调用它们。

所以这只不过是两个缓冲区来存储挂起的调用任务，以延迟它们的实际调用。我正在进一步计算 实际调用的调用任务的数量。 _出队线程(即 long _invoked )和从它们的执行中返回的方法的数量( ObservableCollection 中的每个方法调用 Returned(67) 的 Returned(67) BufferedInvoker 当它完成执行时 - 一个存储在 _returned 变量中的数字。

我的想法是通过 ( _invoked - _returned ) 获取待处理调用的数量，以了解 UI 调度程序的工作负载 - 但令人惊讶的是 _待定总是低于 1 或 2。

所以我现在的问题是，虽然我延迟了对 UI 调度程序的方法调用(使用 Thread.Sleep(delay))，但应用程序在一段时间后开始滞后，这反射(reflect)了 UI 有太多事情要处理的事实用户输入/输出。

但是 - 这就是我真正想知道的 - _待定计数器永远不会达到很高的值，即使 UI 已经被卡住，大部分时间它也是 0。

所以我现在必须找到

(1) 一种测量 UI 调度程序工作负载的方法，以确定 UI 调度程序过度工作的点和

(2) 做一些反对它的事情。

所以现在非常感谢您阅读到这里，我希望您有任何想法如何在 UI 调度程序上调用任意数量的方法而不会使它不堪重负。

提前致谢...强调文字*强调文字*

Answer 1

快速浏览后，我注意到你 sleep 时拿着锁。这意味着在休眠时没有人可以入队，从而使队列无用。

应用程序不会因为队列繁忙而延迟，而是因为锁几乎总是被持有。

我认为您最好删除所有手动实现的队列、锁和监视器，而只使用内置的 ConcurrentQueue。每个 UI 控件和线程一个队列，每个队列一个计时器。

无论如何，这是我的建议:

ConcurrentQueue<Item> queue = new ...;

//timer pulls every 100ms or so
var timer = new Timer(_ => {
 var localItems = new List<Item>();
 while(queue.TryDequeue(...)) { localItems.Add(...); }
 if(localItems.Count != 0) { pushToUI(localItems); }
});

//producer pushes unlimited amounts
new Thread(() => { while(true) queue.Enqueue(...); });

简单的。