一个客户导入设备台账,CSV 有二十来列、两万行。开发在自己机器上试了几百行,点完按钮不到一秒就出结果。现场点下去,窗口先白一下,然后标题栏变成「未响应」,进度条停在 0,鼠标点哪都没反应。用户以为程序死了,打开任务管理器把进程结束掉。事后看日志,导入其实只跑了三秒多,数据也写进去了,只是界面整整三秒没动过一次。

第二个现场更典型。有人把耗时的解析挪到了新线程,为了省事,直接在后台线程里写 StatusText.Text = "已处理 1000 行"。程序立刻抛异常:WinForms 说「线程间操作无效:从不是创建控件 progressBar1 的线程访问它」,WPF 说「调用线程无法访问此对象,因为另一个线程拥有该对象」。开发的第一反应往往是「那我加个锁」,加完照崩——控件的问题不是数据竞争,是线程所有权。

第三个现场最难查。一个按钮事件里写着 var data = LoadAsync().Result;,点了之后窗口永久卡死,CPU 几乎为零,没有异常,也没有日志。把同样的代码放进控制台程序却跑得好好的。区别就在桌面程序有一个「UI 线程」和一个消息循环,.Result 把 UI 线程堵住,而 LoadAsync 的后续代码正排着队等这个线程,互相等,谁都动不了。

这篇解决三件事:耗时的活别占 UI 线程,后台结果要安全回到 UI 线程,等待方式不能把线程堵死。会用一个 CSV 导入窗口跑通完整实现,再讲取消、关窗和异常。版本按 .NET 8 的 WPF 讲,WinForms 写法单独给出。本机用 dotnet-install.ps1 装了 SDK 8.0.427,下面三组实验都实际跑过:UI 线程上 Task.Result 死锁,3 秒仍未返回;await 202–211 ms,续体在线程 9 且为 STA;ConfigureAwait(false) 加 Result 206–209 ms。50 万行 CSV 同步 103 ms、Task.Run 60 ms,取消停在第 490,635 行。

白屏三秒:UI 线程被占住了

桌面程序启动时会创建一个界面线程。这个线程做两件事:创建并拥有窗口上的控件,以及跑一个消息循环。WinForms 里是 Application.Run(form),WPF 里是 Dispatcher.Run()。鼠标移动、键盘输入、窗口需要重绘、定时器到点,这些都被系统排进一个队列,由消息循环一条条取出来处理。

按钮点击也是队列里的一条消息。事件处理函数在 UI 线程上执行,执行期间消息循环停转。如果处理函数里同步读了两万行文件、逐行 Split、再写数据库,三秒内它不会去取下一条消息。于是窗口不重绘,进度条不动,点关闭也没反应。Windows 等五秒左右发现这个窗口不响应消息,就给标题栏加上「未响应」。

一次同步导入的时间线
用户点击导入
事件处理在 UI 线程开始执行
同步读文件、逐行解析
消息循环停转,窗口不重绘
处理结束,界面才恢复响应

「界面卡」不等于「程序慢」。三秒的活本身可以接受,问题是这三秒 UI 线程被独占,用户看不到进度,也没法取消。放到后台线程,消息循环就能继续跑,进度条能动,取消按钮能点。

UI 线程创建控件、跑消息循环。只有它能安全地读写控件属性。它一堵,整个窗口就停摆。
线程池后台任务的执行者。Task.Run 把委托排到池里,适合解析、计算、压缩这类占 CPU 的活。
同步上下文负责把「await 之后的代码」送回原来的线程。WPF 是 DispatcherSynchronizationContext,WinForms 是 WindowsFormsSynchronizationContext。

还有一条容易忽略:控件有线程亲和性。谁创建的控件,谁才有权改它的属性。后台线程改控件时抛异常,不是因为值不合法,而是因为「你不是它的主人」。加锁不会改变所有权,只是让两个线程排队去违反规则。

场景走查:两万行 CSV 不卡界面

需求:点按钮选一个 CSV,后台逐行解析,进度条按百分比前进,列表里滚动显示最近处理的两百条,随时可以取消。先建项目:

dotnet new wpf -n CsvImport -f net8.0
cd CsvImport
dotnet run

界面用四行:按钮行、预览列表、进度条、状态文字。把 MainWindow.xaml 换成:

<Window x:Class="CsvImport.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CSV 导入" Height="420" Width="720">
  <Grid Margin="16">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto"/>
      <RowDefinition Height="*"/>
      <RowDefinition Height="Auto"/>
      <RowDefinition Height="Auto"/>
    </Grid.RowDefinitions>

    <StackPanel Orientation="Horizontal">
      <Button x:Name="PickButton" Content="选择 CSV 并导入"
              Click="Import_Click" Padding="12,6"/>
      <Button x:Name="CancelButton" Content="取消"
              Click="Cancel_Click" Padding="12,6"
              Margin="8,0,0,0" IsEnabled="False"/>
    </StackPanel>

    <ListBox x:Name="PreviewList" Grid.Row="1" Margin="0,12"/>
    <ProgressBar x:Name="Progress" Grid.Row="2"
                 Height="6" Minimum="0" Maximum="100"/>
    <TextBlock x:Name="StatusText" Grid.Row="3"
               Margin="0,12,0,0" Text="就绪"/>
  </Grid>
</Window>

服务类只做一件事:把文件读到内存,再切到线程池逐行解析,每两百行报一次进度。它完全不认识窗口和控件,所以将来能单独测试。

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace CsvImport;

public sealed record ImportProgress(int Rows, int Total, string Code, string[] Batch)
{
    public int Percent => Total <= 0 ? 0 : (int)(Rows * 100L / Total);
}

public static class CsvImportService
{
    public static async Task<int> ImportAsync(
        string path,
        IProgress<ImportProgress>? progress,
        CancellationToken token)
    {
        var lines = await File.ReadAllLinesAsync(path, token)
                              .ConfigureAwait(false);
        var total = Math.Max(lines.Length - 1, 1);

        return await Task.Run(async () =>
        {
            var rows = 0;
            var batch = new List<string>();

            for (var i = 1; i < lines.Length; i++)
            {
                token.ThrowIfCancellationRequested();

                var parts = lines[i].Split(',');
                if (parts.Length < 3) continue;

                rows++;
                batch.Add($"{parts[0].Trim()} · {parts[1].Trim()} · {parts[2].Trim()}");

                if (rows % 200 == 0 || i == lines.Length - 1)
                {
                    progress?.Report(new ImportProgress(
                        rows, total, parts[0].Trim(), batch.ToArray()));
                    batch.Clear();
                    await Task.Delay(1, token).ConfigureAwait(false);
                }
            }

            return rows;
        }, token).ConfigureAwait(false);
    }
}

窗口的 code-behind 负责三件事:建 Progress、把取消令牌传下去、把异常显示出来。注意 Progress 在 UI 线程上创建,它才会把回调投递回 UI 线程。

using System;
using System.Threading;
using System.Windows;
using Microsoft.Win32;

namespace CsvImport;

public partial class MainWindow : Window
{
    private CancellationTokenSource? _cts;

    public MainWindow()
    {
        InitializeComponent();
    }

    private async void Import_Click(object sender, RoutedEventArgs e)
    {
        var dialog = new OpenFileDialog { Filter = "CSV 文件|*.csv" };
        if (dialog.ShowDialog() != true) return;

        var cts = new CancellationTokenSource();
        _cts = cts;
        PickButton.IsEnabled = false;
        CancelButton.IsEnabled = true;
        PreviewList.Items.Clear();
        Progress.Value = 0;

        var progress = new Progress<ImportProgress>(p =>
        {
            if (Dispatcher.HasShutdownStarted) return;

            Progress.Value = p.Percent;
            StatusText.Text = $"已处理 {p.Rows} 行,当前 {p.Code}";

            foreach (var item in p.Batch)
                PreviewList.Items.Add(item);

            while (PreviewList.Items.Count > 200)
                PreviewList.Items.RemoveAt(0);
        });

        try
        {
            var count = await CsvImportService.ImportAsync(
                dialog.FileName, progress, cts.Token);
            StatusText.Text = $"导入完成,共 {count} 行";
        }
        catch (OperationCanceledException)
        {
            StatusText.Text = "已取消,已处理的批次保留";
        }
        catch (Exception ex)
        {
            MessageBox.Show(this, ex.Message, "导入失败",
                MessageBoxButton.OK, MessageBoxImage.Error);
            StatusText.Text = "导入失败";
        }
        finally
        {
            cts.Dispose();
            if (_cts == cts) _cts = null;
            PickButton.IsEnabled = true;
            CancelButton.IsEnabled = false;
        }
    }

    private void Cancel_Click(object sender, RoutedEventArgs e) => _cts?.Cancel();

    protected override void OnClosed(EventArgs e)
    {
        _cts?.Cancel();
        base.OnClosed(e);
    }
}

运行 dotnet run,预期:选一个两万行的 CSV,进度条每两百行前进一格,状态文字不断刷新,列表里保留最近的两百条记录。导入期间拖动窗口、最小化、点取消,界面都有反应。点取消后一两秒内状态变成「已取消」,而不是等整份文件处理完。三秒的解析时间还在,但它不再堵住界面。

这里的分工值得记一下。File.ReadAllLinesAsync 是原生的异步 IO,等待期间不占线程;解析循环是 CPU 活,放进 Task.Run;进度通过 Progress<T> 回报;取消通过 CancellationToken 贯穿。四件事各管一段,不要用一个 Task.Run 把 IO 和计算全包进去。

后台算完了,怎么把结果放回界面

后台线程不能直接改控件,这是 WinForms 和 WPF 共同的规则。区别只在把活送回去的 API 叫什么。

WinForms 用 Control.Invoke 或 BeginInvoke。InvokeRequired 为 true 时说明当前不在控件所属线程,要转交:

if (progressBar1.InvokeRequired)
{
    progressBar1.BeginInvoke(new Action(() =>
        progressBar1.Value = percent));
}
else
{
    progressBar1.Value = percent;
}

WPF 用 Dispatcher。CheckAccess() 返回 false 表示当前线程不是这个 Dispatcher 的线程:

if (!Dispatcher.CheckAccess())
{
    Dispatcher.BeginInvoke(new Action(() =>
        StatusText.Text = message));
    return;
}

StatusText.Text = message;

Invoke:同步等待

把委托送进 UI 队列,然后一直等到 UI 线程执行完。适合「必须拿到返回值」的场合。代价是如果 UI 线程正在等后台线程,后台线程又在这里等 UI,就会互相卡死。Invoke 不适合高频调用。

BeginInvoke:排队就走

把委托放进队列就立刻返回,不阻塞后台线程。适合刷新进度、追加日志。代价是调用方拿不到执行结果,而且投递太快会堆满 UI 队列,界面反而更卡。

后台线程不要用 Invoke 等 UI。如果 UI 线程正在 Join、Wait 这个后台线程,死锁是必然。刷新进度优先用 BeginInvoke,更好的做法是用 Progress<T> 把调度交给框架。

Progress<T> 本质上是帮你做这件事:构造时记下当前的同步上下文,Report 时把回调 Post 回那个上下文。所以它必须在 UI 线程上创建。如果 new Progress<ImportProgress>(...) 写在 Task.Run 里,回调会落在某个线程池线程上,然后照旧碰控件、照旧抛异常——这是「我明明用了 Progress 还是跨线程」的最常见原因。

async/await 把后面的代码放在哪个线程

await 不是「开一个新线程」。它做的是:把当前方法挂起,返回一个未完成的 Task 给调用方;等被等的东西完成,再把方法剩下的部分继续执行。关键问题是「剩下的部分在哪个线程继续」。

默认答案是「原来那个线程」。UI 线程调用 async 方法,遇到第一个 await 时会捕获当前同步上下文;操作完成后,续体被 Post 回 UI 队列,由消息循环执行。所以 UI 方法里 await 之后直接改控件是安全的。

await 前后线程是怎么走的
UI 线程进入 async 方法
遇到 await,方法挂起并返回
消息循环继续处理其他消息
后台操作完成,续体排队回 UI
UI 线程继续执行 await 之后的代码

库代码的写法不一样。一个被复用的服务类往往不关心调用方是不是 UI,它只想在等待完成后尽快继续,不需要回到某个上下文。这时在 await 后面加 ConfigureAwait(false):

public static async Task<string> ReadHeaderAsync(string path)
{
    using var reader = new StreamReader(path);
    var line = await reader.ReadLineAsync().ConfigureAwait(false);
    return line ?? "";
}

它只影响「这一行 await 之后的续体在哪个线程」,不会改变 await 之前代码的运行线程,也不会让后台线程获得改控件的权限。它的价值有两个:库不必为了一个用不上的 UI 上下文付出调度成本;调用方如果用 .Result 同步等待,库内部的续体不需要 UI 线程,死锁概率会小一些。但这不是给 .Result 洗白的理由,同步等待本身仍然该删。

反过来说,UI 事件处理里不要写 ConfigureAwait(false)。写完以后,await 下一行可能在线程池线程上跑,再去碰 StatusText 就是跨线程异常。判断标准很简单:这段代码需要碰界面吗,需要就别加。

IO 等待:用原生异步

读文件、查数据库、发 HTTP 请求,直接用 ReadAllLinesAsync、OpenAsync、SendAsync 这类返回 Task 的 API。等待期间线程被释放,线程池不会被白占。再套一层 Task.Run 只会多一次调度,没有收益。

CPU 计算:用 Task.Run

解析 CSV、压缩、算哈希、生成报表,这些活会一直占着 CPU。放进 Task.Run 才能离开 UI 线程,让消息循环继续跑。注意它不解决 IO 等待,只是把计算挪走。

还有一条边界:async void 只应该出现在事件处理函数里。它的调用方拿不到 Task,没法 await,也没法接住异常。库方法一律返回 Task 或 Task<T>,让调用方决定怎么等。

同步等待为什么会死锁

把上面那个按钮处理写得更「直接」一点,就成了死锁的最小复现:

private async Task<string> LoadAsync()
{
    await Task.Delay(100);
    return "加载完成";
}

private void BadLoad_Click(object sender, RoutedEventArgs e)
{
    var text = LoadAsync().Result;      // 不要这样写
    StatusText.Text = text;
}

点击之后,UI 线程进入 BadLoad_Click,调用 LoadAsync()。方法执行到 await Task.Delay(100),捕获 UI 上下文,返回一个未完成的 Task。接着 .Result 让 UI 线程阻塞,等这个 Task 完成。100 毫秒后延时结束,续体被投递到 UI 的 Dispatcher 队列,等 UI 线程来执行。可 UI 线程正卡在 .Result 上,不会去取队列。本机在 UI 线程上等了 3 秒,Task 仍未完成,UI 也没返回。

死锁的六步循环
UI 线程调用 LoadAsync()
方法遇到 await,挂起并返回
UI 线程在 .Result 上阻塞
后台操作完成,续体投递到 UI 队列
UI 线程仍在阻塞,不取队列
续体永远等不到执行,双方互等

这个现象在控制台程序里复现不出来,因为控制台没有 UI 同步上下文,续体回到线程池就执行了。所以「我在控制台试过,没问题」不能作为桌面代码的依据。.Wait()、.GetAwaiter().GetResult()、Task.WaitAll 是同一个坑的不同写法。

正确写法只有一种:让调用链一路 async,在 UI 方法里 await,不要中途截断成同步等待。如果事件处理必须是 async void,那就 async void,里面照常 await。真正不能改的第三方同步 API 才考虑用 Task.Run 包一层再等,但那是隔离,不是修复。

死锁时任务管理器里 CPU 接近 0,窗口不刷新,也没有异常栈,看起来像「程序挂了但没崩」。排查时先搜代码里的 .Result、.Wait()、GetResult(),再看它们等的任务内部有没有 await 默认回到 UI 上下文。把调用改回 await,通常一行就能解决。

取消、关窗与异常

取消是协作式的。Cancel() 只把令牌置为已取消,后台代码要自己检查:循环里调 ThrowIfCancellationRequested(),或把令牌传给支持取消的 API。没人检查,取消按钮就是摆设。也不要用 Thread.Abort 强杀,文件句柄和事务会停在半路。

关窗也要取消。用户导入到一半直接点右上角关闭,如果后台任务还在跑,它下次 Report 时会碰到已经销毁的控件,轻则异常,重则进程崩溃。窗口的 OnClosed 里发一次取消,进度回调里再检查 Dispatcher.HasShutdownStarted,双保险。回调里还可以判断 IsLoaded,窗口已经不在可视化树里就直接返回。

异常怎么回到 UI?UI 方法里 await,后台抛出的异常会在 await 处原样重抛,而且是在 UI 线程上,外面的 try/catch 接得住。这也是别用 .Result 的原因之一:它会把异常包成 AggregateException,多一层。

async void 事件处理是唯一的例外:异常从 async void 里冒出来后,没有调用方能接,直接交给未处理异常处理器。轻则弹系统错误框,重则进程退出。所以事件处理的整个方法体都要包在 try/catch 里,包括参数校验和对话框调用。真正兜底可以挂 DispatcherUnhandledException,但它只该用来记录日志和提示用户,不该当成正常的错误处理路径。

还有一种「发了就不管」的写法:_ = Task.Run(() => ...)。它的异常要到任务被垃圾回收时才可能被 TaskScheduler.UnobservedTaskException 看到,时机不确定,用户可能早就把窗口关了。要么 await,要么在任务内部把异常转成一个能显示的状态。

取消之后不要假设「什么都没写进去」。如果导入是每两百行提交一次事务,取消时前面的批次已经落库。要么把整份文件放在一个事务里,要么让导入可重入(按主键覆盖、先清后写),并在界面上说清楚「已处理的批次保留」。这两条不选一条,用户重试时就会出现重复数据。

现象、原因与第一步

现象真实原因第一步查什么
点导入后窗口白屏,进度条不动读文件或解析在 UI 线程同步执行,消息循环停转看点击事件里有没有 File.ReadAllLines、长循环或 Thread.Sleep
后台线程改控件抛「线程间操作无效」控件只属于创建它的线程,跨线程赋值被框架拒绝看异常栈里的线程,确认是否用了 InvokeRequired 或 CheckAccess
点按钮后永久卡住,CPU 却接近 0UI 线程在 .Result 或 .Wait() 上等一个要回 UI 的任务全局搜 .Result、.Wait()、GetResult(),改成 await
进度条到最后才跳一下UI 线程被占,或者 Progress 在后台线程创建看 new Progress 写在哪,回调有没有回到 UI 线程
关窗后弹异常或进程残留后台任务没取消,还在向已销毁的控件投递回调看 OnClosed 是否取消,回调是否检查 HasShutdownStarted
async void 里一出错程序就退异常没有调用方接住,直接进了未处理异常处理器看事件处理有没有整体 try/catch,是否只捕获了特定异常
取消后重试出现重复数据分批提交,取消时前面的批次已落库确认事务边界,检查导入是否按主键覆盖或先清后写
界面越导越卡,内存上涨每行都 Report,UI 队列堆积,预览列表无限增长把回报改成每两百行一次,预览列表限制条数

边界与代价

第一,Task.Run 不是「异步」的同义词,它只是把委托丢给线程池。用它包 IO 等待,线程池线程会被阻塞,并发一高就把池子耗光,其他任务排不上队。IO 就用原生异步,CPU 活才用 Task.Run,这个分工不能反。

第二,界面更新有成本。每个 Report 都往 Dispatcher 队列塞一条消息,两万行每行报一次,UI 线程光处理进度就忙不过来,反而更卡。按批回报、限制预览条数是必须的节流;进度条不需要精确到个位。

第三,取消不是即时的。令牌检查点之间的代码会继续执行,一个很长的单次计算没法在中途停下。要缩短取消响应时间,就得把大循环拆小,在每一段之间检查。数据库事务要么整体回滚,要么接受部分提交,这个语义必须提前定。

第四,async/await 让调用链变长,但没让线程变多。等待时不占线程是优点,但别把它当成「后台线程」;真正需要并行计算时才谈线程和并发。

第五,WPF 和 WinForms 都要求控件在 STA 线程上创建。不要为了「后台生成界面」在新线程里 new 控件,也不要把控件实例传给后台线程长期持有。后台只处理数据,界面只处理显示,这条线守住了,跨线程问题会少一大半。

第六,程序退出时不一定等你。普通 Task 跑在线程池的后台线程上,主窗口关了,进程可能直接结束,任务被硬停。需要「关窗前必须写完」的数据,要在关闭事件里等它完成或明确提示用户,而不是假设后台任务会善终。

小结与练习

UI 线程的核心资源是消息循环,任何同步耗时都会让它停转;耗时的计算交给 Task.Run,IO 等待用原生异步;后台结果通过 Progress<T>、Dispatcher 或 BeginInvoke 回到 UI;不要用 .Result、.Wait() 把 UI 线程堵死;取消要贯穿到循环里,关窗要取消并检查 Dispatcher 状态,异常要在 await 或事件处理的 try/catch 里收住。这六件事做完,白屏、跨线程异常、死锁这三类问题就都有固定解法了。

当天可以自己验证的练习:

  1. 把 ImportAsync 里的 Task.Run 去掉,直接在 UI 线程解析,用 Stopwatch 计时,拖动窗口对比卡顿。
  2. 把进度回报从每两百行改成每行一次,导入两万行,观察进度条和窗口的反应。
  3. 在按钮事件里把 await 换成 .Result,复现永久卡死;再改回来,确认恢复。
  4. 导入过程中关闭窗口,观察是否抛异常或进程残留;补上 OnClosed 取消和 HasShutdownStarted 判断后再试。
  5. 把 new Progress<ImportProgress> 挪进 Task.Run 里创建,观察回调落在哪个线程、控件是否报跨线程错误。

下一篇讲打包、安装包与运行时依赖。界面不卡了,数据也能存了,最后一关是把它交到用户手里:目标机器没有 .NET 运行时怎么办,单文件发布和依赖框架发布差在哪,安装包怎么写才不会覆盖用户数据,以及为什么没有代码签名的 exe 会被杀毒软件拦下来。这些不解决,前面写得再对,用户也装不上。