Два потока, использующих одну и ту же переменную, создает проблему

Question

У меня есть список и два потока, которые используют список.

Первый поток получает новые соединения, каждое новое соединение добавляется в список.

Вторая нить, проходящая через список для обработки соединений (используя foreach).

Проблема в том, что иногда, когда второй поток перебирает список, список изменяется до окончания цикла. Я даже попытался создать новую копию списка и зациклить его. Но это создает некоторые другие проблемы.

Я не хочу создавать новый поток для обработки каждого нового соединения, потому что я понял, что слишком много потоков могут повредить производительность. Есть ли другой способ обработки соединений?

Answer 1

2 проблемы.

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

class Mailbox { 
    List<int> list; 

    void Send(int a) { 
     lock(list) { 
       list.Add(a); 
     } 
    } 

    int Receive() { 
     lock(list) { 
      // Enumerate 
      return ...; 
     } 
     } 
} 

Более элегантно, вы можете использовать один из новых коллекций в Concurrent имен, как BlockingCollection. Последнее не в порядке перечисления, но предоставляет метод Take(), который может использоваться для извлечения из него объектов, в то время как производители вставляют их.

2) Избегайте создания нитей gazillion. Вы можете использовать .NET thread pool, чтобы залить столько запросов, сколько захотите, и структура позаботится о том, чтобы сопоставить их с фактическими потоками, не убивая систему.

Answer 2

Я действительно много об этом не знаю, но первая мысль, которая пришла мне на ум:

магазин длина списка и сделать петлю идти

while (var i < lengthoflist) 
{ 
//whatever fancy stuff your code does 
i++; 
} 

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

Answer 3

Самое легкое решение для этого - использовать lock в списке в каждом потоке.

Первый поток:

lock(yourList) 
{ 
    yourList.Add(...); 
} 

Второй поток:

lock(yourList) 
{ 
    foreach(var item in yourList) 
    { 
     ... 
    } 
} 

Это предотвратит первый поток от того, чтобы добавить соединение в то время как второй поток находится в середине итерацию над ним. Если второй поток выполняет итерацию по списку, и первый пытается ввести раздел кода lock, он будет ждать, пока второй поток не завершит цикл над списком.

Answer 4

Как писали другие, вам нужно будет использовать блокировку для управления параллелизмом с этими двумя потоками.

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

На сегодняшний день наиболее эффективным способом чтения из нескольких сокетов является использование асинхронного чтения (Socket.BeginReceive()). Под капотом эти асинхронные методы используют I/O Completion Ports, которые являются высокоэффективными. Сравнительно легко реализовать пользовательские TCP-серверы, которые могут обрабатывать многие тысячи одновременных подключений с использованием методов async Socket.