如何避免 UWP TCP 客户端的延迟？

Question

我正在尝试在 python 服务器（第一台 PC）和 UWP 客户端应用程序（第二台 PC）之间创建 TCP 客户端/服务器程序。 我想模拟一个每 10 毫秒发送一条消息的快速 python 服务器和一个较慢的 UWP 应用程序，其更新功能必须显示每 40 毫秒收到的 last 消息。

为此，在 UWP 端，我创建了一个任务，它读取 python 发送的消息，将其保存在变量 (this.message) 中，然后打印出来。 Update 函数读取此变量并每 40 毫秒打印一次（每次打印后等待 40 毫秒）。

客户端/服务器交换工作，但我得到一个奇怪的行为。 Update 函数有时会“阻塞”相同的值，请参阅输出：

...
[Task] Message = 1105, Ts = 1626767660488
[Task] Message = 1106, Ts = 1626767660495
[Task] Message = 1107, Ts = 1626767660502
[Task] Message = 1108, Ts = 1626767660508
[Task] Message = 1109, Ts = 1626767660512
[Task] Message = 1110, Ts = 1626767660516
[Task] Message = 1111, Ts = 1626767660519
[Task] Message = 1112, Ts = 1626767660523
[Task] Message = 1113, Ts = 1626767660527
[Task] Message = 1114, Ts = 1626767660530
[Task] Message = 1115, Ts = 1626767660534
[Task] Message = 1116, Ts = 1626767660537
[Task] Message = 1117, Ts = 1626767660541
[Update] Message = 1107
[Task] Message = 1118, Ts = 1626767660546
[Task] Message = 1119, Ts = 1626767660551
[Task] Message = 1120, Ts = 1626767660554
[Task] Message = 1121, Ts = 1626767660558
[Task] Message = 1122, Ts = 1626767660562
[Update] Message = 1122
[Update] Message = 1122
[Task] Message = 1123, Ts = 1626767660693
[Task] Message = 1124, Ts = 1626767660697
[Task] Message = 1125, Ts = 1626767660701
[Task] Message = 1126, Ts = 1626767660705
[Task] Message = 1127, Ts = 1626767660708
[Task] Message = 1128, Ts = 1626767660712
[Task] Message = 1129, Ts = 1626767660716
[Task] Message = 1130, Ts = 1626767660720
[Task] Message = 1131, Ts = 1626767660724
[Task] Message = 1132, Ts = 1626767660727
[Task] Message = 1133, Ts = 1626767660731
[Task] Message = 1134, Ts = 1626767660735
[Task] Message = 1135, Ts = 1626767660739
[Task] Message = 1136, Ts = 1626767660742
[Task] Message = 1137, Ts = 1626767660746
[Update] Message = 1124
[Task] Message = 1138, Ts = 1626767660757
[Task] Message = 1139, Ts = 1626767660760
[Task] Message = 1140, Ts = 1626767660764
[Task] Message = 1141, Ts = 1626767660768
[Task] Message = 1142, Ts = 1626767660772
[Task] Message = 1143, Ts = 1626767660775
[Update] Message = 1143
[Task] Message = 1144, Ts = 1626767660834
[Task] Message = 1145, Ts = 1626767660841
[Task] Message = 1146, Ts = 1626767660848
[Task] Message = 1147, Ts = 1626767660856
[Task] Message = 1148, Ts = 1626767660862
[Task] Message = 1149, Ts = 1626767660869
[Task] Message = 1150, Ts = 1626767660875
...

Python 端：

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 4444))
print("[SERVER TCP] Waiting connection ...")
sock.listen(1)
client_socket, address = sock.accept()
data = client_socket.recv(1024)
print(data)
print("[SERVER TCP] Connection done")

x = 0
while True:
   x = x + 1
   msg = f"{x}\n"
   client_socket.send(msg.encode())
   sys.stdout.write(msg)
   time.sleep(0.01)

UWP 应用端 (MainPage.xaml.cs)：

using System;
using System.IO;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;

using System.Threading.Tasks;
using System.Diagnostics;

namespace ClientUWP
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        volatile String message;
        Task T;

        public MainPage()
        {
            this.InitializeComponent();
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            this.StartClient();
            this.Update();
        }

        private async void StartClient()
        {
            try
            {
                var streamSocket = new Windows.Networking.Sockets.StreamSocket();
                var hostName = new Windows.Networking.HostName("192.168.1.50");
                string PortNumber = "4444";
                string request = "Hello, World!";

                await streamSocket.ConnectAsync(hostName, PortNumber);

                using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
                {
                    using (var streamWriter = new StreamWriter(outputStream))
                    {
                        await streamWriter.WriteLineAsync(request);
                        await streamWriter.FlushAsync();
                    }
                }

                T = Task.Run(() =>
                {
                    using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
                    {
                        using (StreamReader streamReader = new StreamReader(inputStream))
                        {
                            while (true)
                            {
                                this.message = streamReader.ReadLine();
                                Debug.WriteLine("[Task] Message = : " + this.message);
                            }
                        }
                    }
                });

            }
            catch (Exception ex)
            {
                Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
                Debug.WriteLine(webErrorStatus.ToString());
            }
        }

        private async void Update()
        {
            while (true)
            {
                Debug.WriteLine("[Update] Message = " + this.message);
                await Task.Delay(40);
            }
            T.Wait();
        }
    }
}

知道如何解决这个问题吗？谢谢！

更新帖子：

当我在Task 中打印时间戳时，Task 似乎冻结到Update 函数结束。

Answer 1

您的数据本质上是随机输出。影响输出的原因有很多，例如网络延迟、CPU 使用率。比如你的网络延迟是160ms，在这160ms期间，你的客户端收不到消息，但是你的更新方法继续，导致连续出现4条更新消息。

因此，我建议您不要将这两个任务分开，您可以在一个任务中完成这些任务。您可以计算消息编号而不是使用Task.Delay(40) 来确定何时打印更新消息，换句话说，您可以每 40 条消息打印一条更新消息

Answer 2

根据 Arya 的回答，由于外部因素，几乎不可能保证操作之间的精确间隔。正如我在 cmets 中提到的那样，您可以或多或少定期触发读取 message 并避免如下读取两次 （这是一个控制台 NET Framework 应用程序；无需完全改变您所做的，我只是适应了非 UWP 应用）：

public class Program
{
    public static void Main(string[] args)
    {
        StartTimer();
        StartClient();
        Console.ReadKey();
    }

    private static string message;
    private static readonly Stopwatch sw = new Stopwatch();
    private static readonly object lockobject = new object();
    private static Timer timer;

    private static void StartClient()
    {
        const string ip = "127.0.0.1";
        const int port = 4444;
        
        var tcpClient = new TcpClient();

        try
        {
            var ipep = new IPEndPoint(IPAddress.Parse(ip), port);
            tcpClient.Connect(ipep);

            Task.Run(() => {
                using (var networkStream = tcpClient.GetStream())
                using (var writer = new StreamWriter(networkStream))
                using (var reader = new StreamReader(networkStream, Encoding.UTF8))
                {
                    writer.WriteLine("Hello, World!");
                    writer.Flush();

                    sw.Start();

                    while (true)
                    {
                        try
                        {
                            // Add this lock for synchronization on message between the threads.
                            lock (lockobject)
                            {
                                message = reader.ReadLine();
                                Console.WriteLine($"[Task]  Message: {message} at {sw.ElapsedMilliseconds}ms");
                            }
                        }
                        catch (Exception ex)
                        {
                            // Break the loop and stop timer in case of exception.
                            timer.Change(Timeout.Infinite, Timeout.Infinite);
                            Console.WriteLine(ex);
                            break;
                        }
                    }
                }
            });
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
            timer.Change(Timeout.Infinite, Timeout.Infinite);
        }
    }

    private static void StartTimer()
    {
        // Replace the loop by a timer and lock on the read message operation.
        timer = new Timer(_ => 
            {
                lock (lockobject)
                {
                    Console.WriteLine($"[Timer] Message: {message} at { sw.ElapsedMilliseconds}ms");
                }
            }, 
            null, 0, 40);
    }
}

输出如下：

[Timer] Message:  at 0ms
[Task]  Message: 1 at 0ms
[Task]  Message: 2 at 18ms
[Task]  Message: 3 at 33ms
[Task]  Message: 4 at 49ms
[Task]  Message: 5 at 65ms
[Timer] Message: 5 at 66ms <- timer message
[Task]  Message: 6 at 81ms
[Task]  Message: 7 at 97ms
[Task]  Message: 8 at 112ms
[Timer] Message: 8 at 113ms <- timer message
[Task]  Message: 9 at 128ms
[Task]  Message: 10 at 144ms
[Task]  Message: 11 at 160ms
[Timer] Message: 11 at 161ms <- timer message
[Task]  Message: 12 at 176ms
[Task]  Message: 13 at 192ms
[Task]  Message: 14 at 207ms
[Timer] Message: 14 at 208ms
[Task]  Message: 15 at 223ms
[Task]  Message: 16 at 239ms
[Task]  Message: 17 at 255ms
[Timer] Message: 17 at 256ms
...

您会定期读取Timer（以前的Update）并且没有重复。如果您需要更准确的间隔，它开始变得更加棘手（请参阅this answer）。不过不确定这是您的场景所必需的。