Mutable vs Immuable pour les applications parallèles [fermé]

Question

Dans l'application, je vous écris, je dois écrire beaucoup de types de base, qui sera très probablement immuable. Mais je me demande comment les types mutable comparer dans les applications parallèles à celles immuables.

Vous pouvez utiliser des serrures avec des objets mutables, non? Comment faut-il par rapport aux autres techniques utilisées avec des types immuables dans les applications parallèles?

Vous êtes au moins loin de l'utilisation de serrures avec des types immuables, non?

Answer 1

Types

• Utilisez les types immuables, autant que possible.
• Utilisez collections thread-safe place de verrous explicites, autant que possible.
• Utilisez uniquement les types mutables quand on n'a pas d'autre choix raisonnable.

Fils

• Utiliser des pools de threads autant que possible.
• Utiliser des boucles sans fin lorsque les pools de threads ne sont pas possibles.
• démarrer et arrêter manuellement les discussions en dernier recours.

Si vous devez utiliser des verrous explicites, documenter les throughly. Surtout quand il s'agit de l'ordre dans lequel vous mémorisez des objets. Si vous savez que les objets Foo sont toujours verrouillés avant des objets Bar et Foo (touche 100) est toujours fermée à clé avant Foo (key = 200), vous n'obtenir des blocages.

Answer 2

La clé de l'écriture d'applications parallélisables est de rester loin de l'état partagé mutable. Partage d'état modifiable entre les fils nécessite une synchronisation qui implique généralement une certaine forme de verrouillage. Utilisation des types immuables peut aider à assurer que vous n'êtes pas état partager accidentellement, en rendant impossible de changer l'état de ces objets. Cependant, ce n'est pas une solution miracle, mais simplement un choix de conception. Si l'algorithme que vous essayez de paralléliser exige un état partagé, vous allez devoir créer une sorte de synchronisation.

mutabilité n'affecte pas le verrouillage.

Answer 3

Lorsque vous utilisez des types mutables vous vous exposez à Write-Après-lecture ou écriture après écriture des erreurs. Ce sont des erreurs de synchronisation associées à la mise à jour d'une valeur alors que d'autres fils sont en train de lire simultanément ou de mettre à jour la valeur.

Pour éviter les erreurs de synchronisation, vous devez utiliser une certaine forme de mécanisme de verrouillage. Si vous utilisez le verrouillage explicite, vous devez être très prudent sur l'ordre d'acquisition de verrous. Si vous ne faites pas attention, vous pouvez introduire des blocages. Par exemple: le thread A acquiert verrouillage X, puis le fil B acquiert verrouillage Y. Un peu plus tard Enfilez une demande de verrouillage Y et B thread demande de verrouillage X. Cela provoque les deux fils d'attendre indéfiniment que les verrous qui ne seront jamais libérés

.

Deux bonnes règles de base pour le verrouillage:

• acquérir des verrous dans un ordre spécifique (par exemple acquérir toujours le verrouillage X avant verrouillage Y)
• Mettre en attente serrures pour une durée aussi courte que possible. les acquérir lorsque vous en avez besoin, et de les libérer dès que vous avez terminé avec le.

Si vous n'écrivez jamais à un objet après sa création, vous n'avez pas besoin de le verrouiller avant d'y accéder. Ainsi, vous aurez pas besoin de verrouiller des objets immuables.

Answer 4

Utilisez des types immuables quand vous le pouvez. Utilisez les types mutables lorsque vous devez (etc sérialisation.).

Utilisez System.Threading.Tasks pour tous vos parallélisation -. Les tâches seront même construire avec la langue en C # 5 et quand async vous attendent des mots-clés sont ajoutés

J'ai écrit un article sur les types mutables / immuables en C #: http://rickyhelgesson.wordpress.com/2012/07/17/mutable-or-immutable-in-a-parallel-world/