Accept fuction causes server shut down about godsharp.socket HOT 4 CLOSED

        int clientCount = 600;

        Console.WriteLine("Enter a key to start ");
        Console.Read();
        for (int i = 0; i < clientCount; ++i)
        {
            new Thread(
                () =>
                {
                    SocketClient client = new SocketClient("127.0.0.1", 7788);

                    client.OnData = (sender, data) =>
                    {
                        //get server data
                        string message = client.Encoding.GetString(data, 0, data.Length);
                        Console.SetCursorPosition(0, 0);
                        Console.WriteLine($"client received data from {sender.RemoteEndPoint.ToString()}: {message}");
                    };

                    try
                    {
                        client.Connect();
                        client.Start();

                        AddSocket(client);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"{ex}");
                    }
                })
            { IsBackground = true }.Start();

        }
        string msg = Console.ReadLine();

        while (msg.ToLower() != "q")
        {

            msg = Console.ReadLine();


            if (msg == "go")
            {

                int num1 = _socketCollection.Count;// new Random().Next(1, clientCount);
                Console.WriteLine($"Random num {num1} ..... ");

                List<string> ids = new List<string>();
                for (int i = 0; i < num1; ++i)
                {
                    int num = new Random().Next(0, _socketCollection.Count);

                    new Thread(
                        () =>
                        {
                            Thread.Sleep(new Random().Next(1000));

                            string input = $"[{num}] {GenerateRandomString(new Random().Next(50))}";
                            _socketCollection[num].Sender.Send(input);

                        })
                    { IsBackground = true }.Start();
                }
            }
        }


        Console.WriteLine("end ...");
        Console.ReadLine();
    }

    private const string CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    /// <summary>
    /// Generates a random string.
    /// </summary>
    /// <param name="count">Length of the string.</param>
    /// <returns>Generated string</returns>
    public static string GenerateRandomString(int count = 8)
    {
        var random = new Random();

        return new string(
            Enumerable.Repeat(CHARACTERS, count)
                      .Select(s => s[random.Next(s.Length)])
                      .ToArray());


    }

    static ConcurrentDictionary<string, SenderData> _clientCollection = new ConcurrentDictionary<string, SenderData>();

    static string OutputLogPath =
        System.IO.Path.Combine(
            new System.IO.FileInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).DirectoryName,
            "Log");
    static void Main()
    {
        string logPath = System.IO.Path.Combine(
            new System.IO.FileInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).DirectoryName, $"log_{DateTime.Now.ToString("HH_mm_ss")}.txt"
            );

        FileStream stream = new FileStream(logPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);

        StreamWriter writer = new StreamWriter(stream);
       
        if (!Directory.Exists(OutputLogPath))
        {
            try
            {
                Directory.CreateDirectory(OutputLogPath);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{ex}");
            }
        }

        Random random = new Random();
        SocketServer server = new SocketServer()
        {
            OnConnected = async (sender) => 
            {

                Events.OnSocketConnectedEvent.Instance.Publish(sender);


             
        
            },
            OnClosed = (tcpSender) =>
            {       
                Events.OnSocketDisconnectedEvent.Instance.Publish(tcpSender);
            }
        };

        server.OnData = async (sender, data) =>
        {
            string message = server.Encoding.GetString(data, 0, data.Length);
            Events.OnSocketReceiveDataEvent.Instance.Publish(new Events.ReceivePacket() { Message = message, Sender = sender });
        };

        Events.OnSocketConnectedEvent.Instance.Subscribe(OnConnected
            ,  Prism.Events.ThreadOption.BackgroundThread
            );
        Events.OnSocketDisconnectedEvent.Instance.Subscribe(OnDisconnected
            ,Prism.Events.ThreadOption.BackgroundThread
            );
        Events.OnSocketReceiveDataEvent.Instance.Subscribe(OnDataReceived);
        server.Listen();
        server.Start();


       
        Console.ReadKey();
        writer.Close();
        stream.Close();
    }

    static object _lockObj = new object();

    static void OnConnected(TcpSender sender)
    {

        string key = sender.RemoteEndPoint.ToString();
        ThreadPool.QueueUserWorkItem(new WaitCallback(
           o =>
           {
               string p = o as string;
               if (p == null)
                   return;
               if (_clientCollection.ContainsKey(p))
                   _clientCollection[p] = new SenderData() { Data = string.Empty };
               else
                   _clientCollection.TryAdd(p, new SenderData() { Data = string.Empty });
               Console.WriteLine($"Count : {_clientCollection.Count}");
           }

           ), key);
    }
    static void OnDisconnected(TcpSender sender)
    {
        string key = sender.RemoteEndPoint.ToString();
        ThreadPool.QueueUserWorkItem(new WaitCallback(
          o =>
          {
              string p = o as string;
              if (p == null)
                  return;
              if (_clientCollection.ContainsKey(p))
              {
                  SenderData data = null;
                  _clientCollection.TryRemove(p, out data);
              }
              Console.WriteLine($"Client {p} is disconnected, totalCount : {_clientCollection.Count}");
          }

          ), key);
    }

    static void OnDataReceived (Events.ReceivePacket packet)
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(
            o =>
            {
                Events.ReceivePacket p = o as Events.ReceivePacket;
                if (p == null)
                    return;
                Console.WriteLine($"[{DateTime.Now.ToString("HH:mm:ss")}] {p.Sender.RemoteEndPoint}::{p.Message}");

            }), packet);
    }

}