Mutante vs imutável para aplicações paralelas [fechado]

Question

Na aplicação que estou escrevendo, eu preciso lotes de gravação de tipos base, que provavelmente será imutável. Mas eu estou querendo saber como mutável tipos comparar em aplicações paralelas para aqueles imutáveis.

Você pode usar fechaduras com objetos mutáveis, certo? Como ele se compara a outras técnicas utilizadas com tipos imutáveis ??em aplicações paralelas?

Você está pelo menos longe de usar fechaduras com tipos imutáveis, certo?

Answer 1

Tipos

• Use tipos imutáveis, tanto quanto possível.
• Usar coleções thread-safe em vez de bloqueios explícitos, tanto quanto possível.
• Use apenas tipos mutáveis ??quando você não tem outra escolha razoável.

Threads

• Usar pools de threads, tanto quanto possível.
• Usar loops infinitos quando pools de threads não são possíveis.
• Inicie manualmente e tópicos de parada como um último recurso.

Se você tem que usar bloqueios explícitos, documento-los minuciosamente. Especialmente quando se trata da ordem em que você bloquear objetos. Se você sabe que objetos Foo são sempre bloqueado antes Bar objetos e que Foo (chave 100) está sempre bloqueado antes Foo (key = 200), você não terá impasses.

Answer 2

A chave para escrever aplicações paralelizáveis ??é para ficar longe de estado compartilhado mutável. Partilhando estado mutável entre fios exige sincronização que envolve, tipicamente, algum tipo de bloqueio. Usando tipos imutáveis ??pode ajudar a garantir que você não está acidentalmente compartilhar estado, tornando impossível para mudar o estado desses objetos. No entanto, esta não é uma bala mágica, mas simplesmente uma escolha de design. Se o algoritmo que você está tentando parallelize requer estado compartilhado, você vai ter que criar algum tipo de sincronização.

A mutabilidade não afeta bloqueio.

Answer 3

Quando você usa tipos mutáveis ??você está expondo-se a escrever-After-leitura ou erros de gravação-após-Write. Estes são erros de sincronização associados à atualização de um valor, enquanto outros segmentos estão simultaneamente ler ou atualizar o valor.

Para evitar erros de sincronização você deve usar alguma forma de mecanismo de bloqueio. Se você usar bloqueios explícitos você precisará ter muito cuidado com o fim de adquirir bloqueios. Se você não for cuidadoso você pode introduzir impasses. Por exemplo: Linha A adquire bloqueio X, então o fio B adquire bloqueio Y. Um tempo depois enfiar uma solicitações de bloqueio Y e linha B solicitações de bloqueio X. Isso faz com que ambos os segmentos para aguardar indefinidamente Locks que nunca serão liberados

.

regras Dois bons de polegar para bloquear:

• fechaduras Adquirir em uma ordem específica (por exemplo, sempre adquirir bloqueio X antes de bloqueio Y)
• fechaduras Mantenha por como tempo a mais curta possível. Adquiri-los quando precisar deles, e liberá-los logo que você é feito com o.

Se você nunca escrever a um objeto após a sua criação, você não precisa para travá-lo antes de acessá-lo. Assim, você não vai precisar para bloquear objetos imutáveis.

Answer 4

Use tipos imutáveis ??quando puder. Use tipos mutáveis ??quando você tem que (serialização etc.).

Use System.Threading.Tasks para toda a sua paralelização -. Tarefas vai mesmo ser construído com a língua em C # 5, quando assíncrono e palavras-chave aguardam são adicionados

Eu escrevi um artigo sobre os tipos mutáveis ??/ imutáveis ??em C #: http://rickyhelgesson.wordpress.com/2012/07/17/mutable-or-immutable-in-a-parallel-world/