WPF UI卡顿自动检测器

这是一个在 WPF 开发中非常实用的需求。为了实现一个健壮（Robust）且高效（Efficient）的 UI 卡顿检测器，我们需要遵循以下核心原则：

1. 独立的看门狗线程：检测逻辑不能运行在 UI 线程上，必须在一个后台线程运行。
2. 低侵入性：检测机制本身不能消耗过多的 CPU 资源，不能频繁打断 UI 线程。
3. 基于 Dispatcher 消息泵：利用 Dispatcher.BeginInvoke 向 UI 线程发送“心跳包”，如果在规定时间内没有执行，则视为卡顿。
4. 优雅退出：在应用关闭时，需要安全地停止检测线程，避免抛出异常。

下面是一个生产环境可用的 UiFreezeDetector 类实现。

1. 核心代码实现 (UiFreezeDetector.cs)

using System;
using System.Diagnostics;
using System.Threading;
using System.Windows;
using System.Windows.Threading;

namespace WpfApp.Utils
{
    /// <summary>
    /// UI 卡顿检测器
    /// 原理：后台线程定期向 UI Dispatcher 发送空任务，若超时未执行则判定为卡顿。
    /// </summary>
    public class UiFreezeDetector : IDisposable
    {
        private readonly Dispatcher _dispatcher;
        private readonly Thread _watchdogThread;
        private readonly ManualResetEvent _pingEvent = new ManualResetEvent(false);
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
        
        private bool _isDisposed;

        /// <summary>
        /// 当检测到卡顿发生时触发
        /// </summary>
        public event EventHandler<FreezeEventArgs> FreezeDetected;

        /// <summary>
        /// 当卡顿结束（UI 恢复响应）时触发
        /// </summary>
        public event EventHandler FreezeRecovered;

        // 配置参数
        private readonly int _timeoutMs; // 判定为卡顿的阈值 (例如 2000ms)
        private readonly int _intervalMs; // 两次检测之间的间隔 (例如 1000ms)

        /// <summary>
        /// 初始化检测器
        /// </summary>
        /// <param name="timeoutMs">卡顿判定阈值（毫秒），建议 > 2000ms</param>
        /// <param name="intervalMs">检测循环间隔（毫秒），建议 > 1000ms</param>
        public UiFreezeDetector(int timeoutMs = 2000, int intervalMs = 1000)
        {
            _dispatcher = Application.Current?.Dispatcher ?? Dispatcher.CurrentDispatcher;
            _timeoutMs = timeoutMs;
            _intervalMs = intervalMs;

            _watchdogThread = new Thread(WatchdogLoop)
            {
                Name = "UI_Freeze_Watchdog",
                IsBackground = true, // 确保主程序退出时线程自动结束
                Priority = ThreadPriority.Highest // 确保在 CPU 繁忙时也能检测
            };
        }

        public void Start()
        {
            if (_watchdogThread.ThreadState.HasFlag(System.Threading.ThreadState.Unstarted))
            {
                _watchdogThread.Start();
                Debug.WriteLine("UI Freeze Detector Started.");
            }
        }

        public void Stop()
        {
            _cts.Cancel();
        }

        private void WatchdogLoop()
        {
            while (!_cts.Token.IsCancellationRequested && !_isDisposed)
            {
                // 1. 检查 Dispatcher 是否还在运行，应用退出则停止
                if (_dispatcher.HasShutdownStarted) break;

                // 2. 重置信号量
                _pingEvent.Reset();

                // 3. 向 UI 线程投递一个低优先级的任务
                // 使用 DispatcherPriority.Normal 或 Input，确保能检测到输入阻塞
                var operation = _dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
                {
                    // UI 线程执行到这里，说明没有卡死，设置信号量
                    _pingEvent.Set();
                }));

                // 4. 在后台线程等待信号量
                // 如果 UI 线程顺畅，它会很快 Set()，WaitOne 立即返回 true
                // 如果 UI 线程卡死，超过 _timeoutMs 后，WaitOne 返回 false
                bool signaled = _pingEvent.WaitOne(_timeoutMs);

                if (!signaled)
                {
                    // --- 检测到卡顿 ---
                    
                    // 只有在没有取消的时候才报告
                    if (!_cts.Token.IsCancellationRequested)
                    {
                        NotifyFreeze();

                        // 等待 UI 恢复（防止连续触发事件，直到本次卡顿结束）
                        _pingEvent.WaitOne(); 
                        
                        // --- 卡顿恢复 ---
                        FreezeRecovered?.Invoke(this, EventArgs.Empty);
                    }
                }

                // 5. 休息一段时间再进行下一次检测，避免检测本身占用过多资源
                try
                {
                    Task.Delay(_intervalMs, _cts.Token).Wait();
                }
                catch (AggregateException) { /* 忽略取消异常 */ }
            }
        }

        private void NotifyFreeze()
        {
            // 注意：不要在这里直接调用 UI 元素，因为这里是后台线程，且 UI 可能正忙
            // 此时获取 UI 线程的堆栈信息比较困难（需要 unsafe 或 Debugger API），
            // 但我们可以记录时间戳。
            
            var args = new FreezeEventArgs
            {
                DetectedTime = DateTime.Now,
                DurationThreshold = _timeoutMs
            };

            Debug.WriteLine($"[UI FREEZE DETECTED] Time: {args.DetectedTime}");
            
            // 触发事件
            FreezeDetected?.Invoke(this, args);
        }

        public void Dispose()
        {
            if (_isDisposed) return;
            _isDisposed = true;
            _cts.Cancel();
            _pingEvent.Dispose();
            _cts.Dispose();
        }
    }

    public class FreezeEventArgs : EventArgs
    {
        public DateTime DetectedTime { get; set; }
        public int DurationThreshold { get; set; }
    }
}

2. 使用方法

建议在 App.xaml.cs 的 OnStartup 中启动它，使其伴随整个应用程序生命周期。

using System.Windows;

namespace WpfApp
{
    public partial class App : Application
    {
        private WpfApp.Utils.UiFreezeDetector _freezeDetector;

        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            // 初始化检测器：如果 UI 停顿超过 3 秒则报警，每隔 1 秒检测一次
            _freezeDetector = new WpfApp.Utils.UiFreezeDetector(timeoutMs: 3000, intervalMs: 1000);
            
            _freezeDetector.FreezeDetected += (s, args) =>
            {
                // 注意：这里是后台线程！不要直接操作 UI。
                // 可以记录日志、生成 Dump 文件等。
                System.Diagnostics.Debug.WriteLine($"!!! UI 卡顿发生在 {args.DetectedTime} !!!");
                
                // 只有在非常必要时才尝试强制弹窗（可能会失败，因为 UI 正忙）
                // MessageBox.Show("检测到界面卡顿！"); 
            };

            _freezeDetector.FreezeRecovered += (s, args) => 
            {
                System.Diagnostics.Debug.WriteLine(">>> UI 已恢复响应 <<<");
            };

            _freezeDetector.Start();
        }

        protected override void OnExit(ExitEventArgs e)
        {
            _freezeDetector.Stop();
            _freezeDetector.Dispose();
            base.OnExit(e);
        }
    }
}

3. 代码健壮性与高效性分析

为什么这个实现是“高效”的？

1. 使用 BeginInvoke 而非 Invoke：看门狗线程发送消息给 Dispatcher 是异步的，不会阻塞看门狗线程本身。
2. 使用 WaitHandle (ManualResetEvent)：这是操作系统内核级的同步原语。等待期间，看门狗线程处于 Sleep/Wait 状态，CPU 占用率几乎为 0。
3. 休眠间隔 (_intervalMs)：检测完成后，线程会主动休眠，避免在那儿死循环空转。

为什么这个实现是“健壮”的？

1. 处理应用退出 (HasShutdownStarted)：WPF 关闭时 Dispatcher 会停止处理消息。代码中显式检查了此状态，防止在应用关闭时误报卡顿或抛出 ObjectDisposedException。
2. 避免事件洪流：
   • 代码逻辑中：if (!signaled) { ... _pingEvent.WaitOne(); }
   • 这行代码非常关键。一旦检测到卡顿，看门狗会挂起，一直等到那个被阻塞的任务终于执行完毕（即 UI 恢复）后，才进行下一次检测。这避免了在一次长达 10 秒的卡顿中触发 5 次“卡顿 2 秒”的报警。
3. 独立的 CancellationToken：使用 CancellationTokenSource 来优雅地打断 Task.Delay，实现立即停止。
4. 线程优先级：将看门狗线程设为 Highest，防止因为 CPU 满载（导致 UI 卡顿的常见原因）导致检测线程本身也拿不到时间片去检测。

4. 进阶：如何获取卡顿时的堆栈？

这是最难的部分。因为卡顿检测是在后台线程触发的，而我们需要的是 UI 线程的堆栈。

在纯 .NET (不使用非托管 Debugger API) 中，获取另一个线程的实时堆栈是非常困难且不安全的（Thread.Suspend 已废弃且危险）。

推荐的折衷方案：
如果需要定位卡顿原因，建议在 FreezeDetected 事件中：

1. 记录日志：记录发生时间。
2. 创建 MiniDump：调用 Windows API (MiniDumpWriteDump) 生成一个内存快照。
3. 事后分析：使用 Visual Studio 或 WinDbg 打开 Dump 文件，直接看主线程停在哪里。这是最准确的方法。

如果仅用于开发阶段调试，可以简单地暂停调试器，但对于生产环境，生成 Dump 是标准做法。

---

模拟卡顿

<Button Content="模拟卡顿" Click="Button_Click"></Button>

private void Button_Click(object sender, RoutedEventArgs e)
{
    log4.InfoFormat($"模拟卡顿!!!{DateTime.Now}");
    var endTime = DateTime.Now.AddSeconds(60);
    while (DateTime.Now < endTime)
    {
        // 模拟繁重计算，阻塞 UI 线程
        Thread.Sleep(10000); 
    }
}