Use linked list to track the dispatchers

Author: sakno

src/cluster/DotNext.Net.Cluster/Net/Multiplexing/MultiplexedListener.LinkedTaskList.cs

@@ -0,0 +1,74 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace DotNext.Net.Multiplexing;
+
+partial class MultiplexedListener
+{
+    private sealed class TaskNode
+    {
+        private readonly WeakReference<Task> task;
+        private TaskNode? next;
+
+        private TaskNode(Task task)
+            => this.task = new(task);
+
+        private TaskNode? CleanupAndGetNext()
+        {
+            var result = next;
+            next = null;
+            return result;
+        }
+
+        private Task AttachedTask
+        {
+            get
+            {
+                if (!task.TryGetTarget(out var result))
+                    result = Task.CompletedTask;
+
+                return result;
+            }
+        }
+
+        private bool IsCompleted => AttachedTask.IsCompleted;
+
+        public static void Add([NotNull] ref TaskNode? head, Task task)
+        {
+            RemoveCompleted(ref head);
+            head = new(task) { next = head };
+        }
+
+        private static void RemoveCompleted(ref TaskNode? head)
+        {
+            for (TaskNode? current = head, previous = null; current is not null;)
+            {
+                if (current.IsCompleted)
+                {
+                    ref var next = ref previous is not null ? ref previous.next : ref head;
+                    next = current = current.CleanupAndGetNext(); // previous remains unchanged
+                }
+                else
+                {
+                    previous = current;
+                    current = current.next;
+                }
+            }
+        }
+
+        public static IEnumerable<Task> GetTasks(TaskNode? head)
+        {
+            return head is null ? [] : GetTasksImpl(head);
+
+            static IEnumerable<Task> GetTasksImpl(TaskNode? node)
+            {
+                while (node is not null)
+                {
+                    if (node is { AttachedTask: { IsCompleted: false } task })
+                        yield return task;
+
+                    node = node.next;
+                }
+            }
+        }
+    }
+}

src/cluster/DotNext.Net.Cluster/Net/Multiplexing/MultiplexedListener.cs

@@ -131,35 +131,23 @@ private async Task ListenAsync()
         }
 
         readiness.TrySetResult();
-        var connections = new HashSet<WeakReference<Task>>();
+        var headNode = default(TaskNode?);
         try
         {
             while (!lifetimeToken.IsCancellationRequested)
             {
                 var clientSocket = await listeningSocket.AcceptAsync(lifetimeToken).ConfigureAwait(false);
                 ConfigureAcceptedSocket(clientSocket);
-                connections.Add(new(DispatchAsync(clientSocket)));
-
-                // GC: remove completed tasks
-                connections.RemoveWhere(IsCompleted);
+                TaskNode.Add(ref headNode, DispatchAsync(clientSocket));
             }
         }
         finally
         {
             listeningSocket.Dispose();
-            await Task.WhenAll(connections.Select(Unwrap)).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
-            connections.Clear();
-        }
-
-        static bool IsCompleted(WeakReference<Task> taskRef)
-            => !taskRef.TryGetTarget(out var task) || task.IsCompleted;
-
-        static Task Unwrap(WeakReference<Task> taskRef)
-        {
-            if (!taskRef.TryGetTarget(out var task))
-                task = Task.CompletedTask;
-
-            return task;
+            foreach (var task in TaskNode.GetTasks(headNode))
+            {
+                await task.ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
+            }
         }
     }