MvvmScaffoldFrame48/MvvmScaffoldFrame48.DLL/ThreadManager/CommunicationThread.cs

using MvvmScaffoldFrame48.Model.ResultModel;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MvvmScaffoldFrame48.DLL.ThreadManager
{
    /// <summary>
    /// 通信线程管理类
    /// 管理通信线程的生命周期和数据传输
    /// </summary>
    public class CommunicationThread
    {
        public bool IsRunning { get; private set; }
        public CancellationTokenSource CancellationTokenSource { get; private set; }
        public Task CommunicationTask { get; private set; }

        // 待发送数据队列
        private readonly ConcurrentQueue<CameraProcessEventArgsResultModel> _dataQueue = new ConcurrentQueue<CameraProcessEventArgsResultModel>();
        private readonly SemaphoreSlim _queueSemaphore = new SemaphoreSlim(0);

        /// <summary>
        /// 发送数据到通信设备
        /// </summary>
        public void SendData(CameraProcessEventArgsResultModel data)
        {
            _dataQueue.Enqueue(data);
            _queueSemaphore.Release();
        }

        /// <summary>
        /// 启动通信线程
        /// </summary>
        public void Start()
        {
            if (IsRunning)
                return;

            CancellationTokenSource = new CancellationTokenSource();
            var token = CancellationTokenSource.Token;

            CommunicationTask = Task.Factory.StartNew(() => CommunicationLoop(token),
                token, TaskCreationOptions.LongRunning, TaskScheduler.Default);

            IsRunning = true;
            Console.WriteLine("通信线程已启动");
        }

        /// <summary>
        /// 停止通信线程
        /// </summary>
        public async void Stop()
        {
            if (!IsRunning)
                return;

            CancellationTokenSource.Cancel();

            try
            {
                if (CommunicationTask != null)
                    await CommunicationTask;
            }
            catch (OperationCanceledException)
            {
                // 正常取消
            }

            IsRunning = false;
            Console.WriteLine("通信线程已停止");
        }

        private async void CommunicationLoop(CancellationToken token)
        {
            try
            {
                while (!token.IsCancellationRequested)
                {
                    // 等待数据
                    await _queueSemaphore.WaitAsync(token);

                    // 从队列获取数据
                    if (_dataQueue.TryDequeue(out CameraProcessEventArgsResultModel data))
                    {
                        // 执行通信逻辑
                        PerformCommunication(data);
                    }

                    // 1ms休眠
                    await Task.Delay(1, token);
                }
            }
            catch (OperationCanceledException)
            {
                // 线程被取消，正常退出
            }
            catch (Exception ex)
            {
                Console.WriteLine($"通信线程异常: {ex.Message}");
            }
        }

        private void PerformCommunication(CameraProcessEventArgsResultModel data)
        {
            // 实现具体通信逻辑
            Console.WriteLine($"通信线程发送数据: 相机{data.CameraId}, 时间{data.Timestamp}");
        }
    }
}