A iteração sobre uma matriz com um loop for é uma operação segura de thread em C #? Que tal iterar um IEnumerable <T> com um loop foreach?

Com base no meu entendimento, dado um array C #, o ato de iterar sobre o array simultaneamente de vários threads é uma operação segura para threads.

Ao iterar sobre a matriz, quero dizer a leitura de todas as posições dentro da matriz por meio de um loop antigo simplesfor . Cada thread está simplesmente lendo o conteúdo de um local de memória dentro da matriz, ninguém está escrevendo nada, então todos os threads lêem a mesma coisa de maneira consistente.

Este é um pedaço de código fazendo o que escrevi acima:

public class UselessService 
{
   private static readonly string[] Names = new [] { "bob", "alice" };

   public List<int> DoSomethingUseless()
   {
      var temp = new List<int>();

      for (int i = 0; i < Names.Length; i++) 
      {
        temp.Add(Names[i].Length * 2);
      }

      return temp;
   }
}

Portanto, meu entendimento é de que o método DoSomethingUseless é seguro para threads e que não há necessidade de substituí-lo string[]por um tipo seguro de thread (como ImmutableArray<string>por exemplo).

Estou correcto ?

Agora vamos supor que temos uma instância de IEnumerable<T>. Não sabemos qual é o objeto subjacente, apenas sabemos que temos um objeto implementado IEnumerable<T>, portanto, podemos iterá-lo usando o foreachloop.

Com base no meu entendimento, nesse cenário, não há garantia de que a iteração desse objeto a partir de vários threads simultaneamente seja uma operação segura de thread. Em outras palavras, é perfeitamente possível que a iteração sobre a IEnumerable<T>instância de diferentes threads ao mesmo tempo quebre o estado interno do objeto, para que ele seja corrompido.

Estou correto neste ponto?

E a IEnumerable<T>implementação da Arrayclasse? É thread seguro?

Em outras palavras, o seguinte encadeamento de código é seguro? (esse é exatamente o mesmo código acima, mas agora a matriz é iterada usando um foreachloop em vez de um forloop)

public class UselessService 
{
   private static readonly string[] Names = new [] { "bob", "alice" };

   public List<int> DoSomethingUseless()
   {
      var temp = new List<int>();

      foreach (var name in Names) 
      {
        temp.Add(name.Length * 2);
      }

      return temp;
   }
}

Existe alguma referência informando que IEnumerable<T>implementações na biblioteca de classes base do .NET são realmente seguras contra threads?

A iteração sobre uma matriz com um loop for é uma operação segura de thread em C #?

Se você está falando estritamente sobre a leitura de vários segmentos , que será segmento seguro para Arraye List<T>e apenas sobre cada coleção escrito por Microsoft, independentemente de se você estiver usando um forou foreachloop. Especialmente no exemplo, você tem:

var temp = new List<int>();

foreach (var name in Names)
{
  temp.Add(name.Length * 2);
}

Você pode fazer isso em quantos threads quiser. Todos lerão os mesmos valores Namesfelizes.

Se você escrever a partir de outro tópico (essa não foi sua pergunta, mas vale a pena notar)

Iterando sobre um loop Arrayou List<T>com um forloop, ele continuará lendo e lerá alegremente os valores alterados à medida que você os encontrar.

Iterando com um foreachloop, isso depende da implementação. Se um valor de uma forma Arraymudar parcialmente através de um foreachloop, ele continuará enumerando e fornecendo os valores alterados.

Com List<T>, depende do que você considera "thread safe". Se você está mais preocupado com a leitura de dados precisos, é meio "seguro", pois gera uma exceção no meio da enumeração e informa que a coleção foi alterada. Mas se você considera que lançar uma exceção não é segura, não é seguro.

Mas vale a pena notar que esta é uma decisão de design List<T>, existe um código que procura explicitamente alterações e gera uma exceção. As decisões de design nos levam ao próximo ponto:

Podemos assumir que toda coleção implementada IEnumerableé segura para ler em vários segmentos?

Na maioria dos casos , será, mas a leitura segura de threads não é garantida. O motivo é que todos IEnumerableexigem uma implementação de IEnumerator, que decide como percorrer os itens da coleção. E, como em qualquer classe, você pode fazer o que quiser , incluindo coisas não seguras para threads, como:

• Usando variáveis ​​estáticas
• Usando um cache compartilhado para ler valores
• Não fazendo nenhum esforço para lidar com casos em que a coleção é alterada na enumeração intermediária
• etc.

Você pode até fazer algo estranho, como fazer GetEnumerator()retornar a mesma instância do seu enumerador toda vez que for chamado. Isso poderia realmente gerar alguns resultados imprevisíveis.

Considero que algo não é seguro para threads, se puder resultar em resultados imprevisíveis. Qualquer uma dessas coisas pode causar resultados imprevisíveis.

Você pode ver o código-fonte do Enumeratorque List<T>usa , para que ele não faça nada estranho, o que indica que a enumeração List<T>de vários segmentos é segura.

Afirmar que seu código é seguro para threads significa que devemos tomar suas palavras como garantidas de que não há código dentro do UselessServiceque tentará substituir simultaneamente o conteúdo da Namesmatriz por algo como "tom" and "jerry"ou (mais sinistro) null and null. Por outro lado, utilizando um ImmutableArray<string>iria garantir que o código é thread-safe, e todo mundo poderia ter certeza sobre isso só de olhar o tipo do campo somente leitura estático, sem ter de inspeccionar cuidadosamente o resto do código.

Você pode achar interessantes esses comentários no código-fonte do ImmutableArray<T>, sobre alguns detalhes de implementação dessa estrutura:

Uma matriz somente leitura com tempo de pesquisa indexável O (1).

Esse tipo tem um contrato documentado de ter exatamente um campo do tipo de referência em tamanho. Nossa própria System.Collections.Immutable.ImmutableInterlockedclasse depende disso, assim como outras externamente.

AVISO IMPORTANTE PARA MANUTORES E REVISORES:

Esse tipo deve ser seguro para threads. Como uma estrutura, ele não pode proteger seus próprios campos de serem alterados de um encadeamento enquanto seus membros estão executando em outros encadeamentos, porque as estruturas podem mudar de lugar simplesmente reatribuindo o campo que contém essa estrutura. Portanto, é extremamente importante que Todo membro desreferencie uma thisvez. Se um membro precisar fazer referência ao campo da matriz, isso conta como uma desreferência de this. Chamar outros membros da instância (propriedades ou métodos) também conta como desreferenciação this. Qualquer membro que precise usar thismais de uma vez deve atribuirthispara uma variável local e use-a no restante do código. Isso efetivamente copia o campo one na estrutura para uma variável local, para que seja isolado de outros threads.