如何在周期性后台任务与用户按钮点击间共享串口？

问题背景 #

我正在开发一个C# WinForms GUI用于控制实验室设备，界面包含按钮和标签，既要通过串口轮询显示设备状态，也要支持用户发送命令。设备的命令与返回数据长度会随设备状态、收发命令不同而变化。

当前实现的问题 #

目前用Windows.Forms.Timer回调实现轮询，主线程中通过两个布尔变量处理串口访问冲突，但会导致GUI卡顿（更新时UI无响应）。虽然多数用户能接受，但存在同事在卡顿期间频繁点击的情况。现有方案可行但繁琐，希望优化实现。

现有代码框架 #

class MyCoolGadget
{
   private bool updateInProgress;
   private bool commandInProgress;
   private System.Windows.Forms.Timer updateTimer = new System.Windows.Forms.Timer();

   public MyCoolGadget()
   {
      updateTimer.Interval = 1000;
      updateTimer.Tick += new EventHandler(updateCallback);
      updateInProgress = false;
      commandInProgress = false;
      // Other constructor stuff
   }

   private void updateCallback(object sender, EventArgs e)
   {
      Update();
   }

   // This method is called by other class methods as well as by GUI element callbacks
   public byte[] sendCommand(byte id, byte[] payload) 
   {
      string caller = new System.Diagnostics.StackFrame(1).GetMethod().Name;

      // Loop here checks to see if there is an update is in progress and it needs to wait
      // for the serial port. If Update is the caller, we ignore the wait or we get stuck 
      // in an infinite loop. This is part of what i want to clean up.
      while (updateInProgress && (caller != "Update"))
      {
         Thread.Sleep(25);
      }

      if (caller != "Update")
      {
         commandInProgress = true;
      }

      // Build message, send it, get answer

      if (caller != "Update")
      {
         commandInProgress = false;
      }

      return answer;
   }

   // This method is called every second by the timer's callback
   private void Update()
   {
      byte[] replyBuffer;

      while (commandInProgress)
      {
         Thread.Sleep(10);
      }

      updateInProgress = true;

      replyBuffer = sendCommand(id1, payload1);
      // Update properties based on reply. GUI elements bound to class properties so they update
      // without further action on my part.

      replyBuffer = sendCommand(id2, payload2);
      // Update properties based on reply.

      replyBuffer = sendCommand(id3, payload3);
      // Update properties based on reply.

      updateInProgress = false;
   }
}

优化目标 #

将Update方法移至后台线程执行以避免UI卡顿，同时保证用户触发的命令与轮询操作的串口访问不冲突。尝试过async/await但出错，也了解过委托但不清楚如何迁移任务到后台，需要适合硬件开发者的示例和解释。

优化方案与代码示例 #

核心改进点 #

1. 用SemaphoreSlim替代布尔变量，实现可靠的串口访问互斥控制
2. 基于async/await实现异步操作，彻底释放UI线程
3. 确保UI更新始终在主线程执行，避免跨线程异常

完整优化代码 #

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

class MyCoolGadget
{
    // 串口访问互斥锁：初始1个许可，同一时间仅允许一个操作访问串口
    private readonly SemaphoreSlim _serialAccessLock = new SemaphoreSlim(1, 1);
    private System.Windows.Forms.Timer _updateTimer = new System.Windows.Forms.Timer();

    // GUI控件示例（根据实际项目替换）
    private Label _device1StatusLabel;
    private Label _device2StatusLabel;
    private Label _device3StatusLabel;

    public MyCoolGadget()
    {
        _updateTimer.Interval = 1000;
        // 异步Timer回调，避免阻塞UI线程
        _updateTimer.Tick += async (sender, e) => await RunDeviceUpdateAsync();
        _updateTimer.Start();

        // 其他初始化逻辑（如串口初始化、控件绑定等）
    }

    /// <summary>
    /// 异步发送设备命令，自动处理串口互斥
    /// </summary>
    public async Task<byte[]> SendDeviceCommandAsync(byte deviceId, byte[] payload, CancellationToken token = default)
    {
        byte[] replyBuffer = Array.Empty<byte>();

        // 异步等待串口访问许可，不会阻塞UI线程
        await _serialAccessLock.WaitAsync(token);
        try
        {
            // ========== 替换为实际串口操作 ==========
            // 1. 构建符合设备协议的命令帧
            // byte[] commandFrame = BuildCommandFrame(deviceId, payload);
            // 2. 异步写入串口
            // await _serialPort.WriteAsync(commandFrame, 0, commandFrame.Length, token);
            // 3. 异步读取返回数据（需根据设备协议处理动态长度）
            // replyBuffer = await ReadDeviceReplyAsync(_serialPort, token);

            // 模拟硬件通信延迟（实际开发中删除此段）
            await Task.Delay(80, token);
            replyBuffer = new byte[] { deviceId, 0x00, 0x01 }; // 模拟设备返回数据
            // ======================================
        }
        finally
        {
            // 无论操作成功/失败，都释放串口访问许可
            _serialAccessLock.Release();
        }

        return replyBuffer;
    }

    /// <summary>
    /// 异步执行设备状态轮询，后台运行不阻塞UI
    /// </summary>
    private async Task RunDeviceUpdateAsync()
    {
        // 暂停Timer，避免前一次轮询未完成时重复触发
        _updateTimer.Stop();
        try
        {
            // 依次轮询设备状态
            var device1Reply = await SendDeviceCommandAsync(0x01, new byte[] { 0x00 });
            UpdateGuiLabel(_device1StatusLabel, $"设备1: {BitConverter.ToString(device1Reply)}");

            var device2Reply = await SendDeviceCommandAsync(0x02, new byte[] { 0x00 });
            UpdateGuiLabel(_device2StatusLabel, $"设备2: {BitConverter.ToString(device2Reply)}");

            var device3Reply = await SendDeviceCommandAsync(0x03, new byte[] { 0x00 });
            UpdateGuiLabel(_device3StatusLabel, $"设备3: {BitConverter.ToString(device3Reply)}");
        }
        catch (OperationCanceledException)
        {
            // 处理任务取消（如程序关闭时）
        }
        finally
        {
            // 重启Timer，继续下一次轮询
            _updateTimer.Start();
        }
    }

    /// <summary>
    /// 安全更新UI标签，自动处理跨线程问题
    /// </summary>
    private void UpdateGuiLabel(Label label, string text)
    {
        if (label.InvokeRequired)
        {
            // 不在UI线程时，委托回主线程执行更新
            label.Invoke(new Action(() => UpdateGuiLabel(label, text)));
        }
        else
        {
            label.Text = text;
        }
    }
}

关键部分解释 #

1. SemaphoreSlim 互斥控制

   • 替代原有的布尔变量，WaitAsync异步等待串口访问许可，不会阻塞UI线程
   • finally块确保许可被释放，避免死锁
   • 无需判断调用者，逻辑更简洁可靠

2. Async/Await 异步架构

   • 所有串口操作和轮询逻辑改为异步，UI线程在await期间会回到消息循环处理用户操作，彻底解决卡顿
   • Timer回调使用异步lambda，避免同步执行阻塞UI

3. UI线程安全更新

   • UpdateGuiLabel方法通过InvokeRequired判断是否在UI线程，确保所有UI操作都在主线程执行，避免跨线程异常

注意事项 #

• 必须使用串口的异步API（WriteAsync/ReadAsync），同步API会阻塞线程，失去异步意义
• 动态长度的返回数据需根据设备协议处理（如先读取长度字节，再读取对应长度的数据）
• 可在程序关闭时通过CancellationToken终止所有异步任务，避免资源泄漏

内容的提问来源于stack exchange，提问作者MediocreCoffee