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

Question

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

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

客户机/服务器交换工作正常，但我得到一个奇怪的行为。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

根据Arya的回答，由于外部因素，几乎不可能保证两次操作之间的精确间隔。正如我在评论中提到的，您可以或多或少地定期触发对message的阅读，并避免阅读两次，如下所示（这是一个Console 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）。但不确定您的场景是否需要这样做

Answer 2

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

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