C#: Обработка сигнала завершения в потоке обработчика TCP?

Question

Я использую класс TcpClient в C#.

Каждый раз, когда есть новый запрос соединения tcp, обычной практикой является создание нового потока для его обработки. И должно быть возможно, чтобы основной поток прекратил эти потоки обработчиков в любое время.

Мое решение для каждого из этих обработчиков нити следующим образом:

1 Check NetworkStream's DataAvailable method 
    1.1 If new data available then read and process new data 
    1.2 If end of stream then self terminate 
2 Check for terminate signal from main thread 
    2.1 If terminate signal activated then self terminate 
3 Goto 1. 

Проблема с этим избирательного подхода состоит в том, что все эти нити обработчик будет принимать до значительных ресурсов процессора и особенно, если есть огромное количество этих потоков. Это делает его крайне неэффективным.

Есть ли лучший способ сделать это?

Answer 1

См. Asynchronous Server Socket Example, чтобы узнать, как это сделать «.NET way», без создания новых потоков для каждого запроса.

Answer 2

Помню, что я работаю над аналогичным сервисом Windows. Это сервер NTRIP, который может принимать около 1000 TCP-соединений и направлять данные в NTRIP Caster.

Если у вас есть выделенный сервер для этого приложения, это не будет проблемой, если вы не добавите больше кода для каждого потока (File IO, Database и т. Д.), Хотя в моем случае у меня также была обработка базы данных для входа в систему/выхода для каждого соединения).

Вещь, чтобы не упустить:

1. Bandwidth, когда нить доходит до 600 или около того. Вы начинаете видеть отсоединения когда окно TCP буфера забиты по какой-то причине или доступная полоса пропускание дотягивает
2. Операционная система, на которой вы работаете это приложение может иметь некоторые ограничения, которые могут привести к Отключению

В выше, возможно, не применимо в вашем случае, но я просто хотел, чтобы он поместил его сюда, потому что я столкнулся с этим во время разработки.

Answer 3

Вы правы, что не хотите, чтобы все ваши потоки «заняты ожиданием» (т. Е. Выполняли небольшой цикл снова и снова). Вы либо хотите, чтобы они блокировались, либо вы хотите использовать асинхронный ввод-вывод.

Как отметил Джон Сондерс, асинхронный ввод-вывод - это «правильный путь», поскольку он может масштабироваться до сотен подключений. В принципе, вы вызываете BeginRead() и передаете ему функцию обратного вызова. BeginRead() немедленно возвращается, и когда данные поступают, функция обратного вызова вызывается в потоке из пула потоков. Функция обратного вызова обрабатывает данные, снова вызывает BeginRead(), а затем возвращает, которая возвращает поток обратно в пул.

Однако, если вы будете открывать только несколько подключений одновременно, совершенно нормально создавать поток для каждого соединения. Вместо проверки свойства DataAvailable в цикле продолжите вызов и вызовите функцию Read(). Поток блокирует, не потребляя процессор, пока данные не будут доступны для чтения. Если соединение потеряно или вы закрываете его из другого потока, вызов Read() выдает исключение, которое вы можете обработать, прекратив поток вашего читателя.

Answer 4

Верьте или нет, что 1000 тиков сна действительно будут держать все в движении.

private readonly Queue<Socket> sockets = new Queue<Socket>(); 
private readonly object locker = new object(); 
private readonly TimeSpan sleepTimeSpan = new TimeSpan(1000); 
private volatile Boolean terminate; 

private void HandleRequests() 
{ 
    Socket socket = null; 

    while (!terminate) 
    { 
     lock (locker) 
     { 
      socket = null; 
      if (sockets.Count > 0) 
      { 
       socket = sockets.Dequeue(); 
      } 
     } 

     if (socket != null) 
     { 
      // process 
     } 

     Thread.Sleep(sleepTimeSpan); 
    } 
}