Wat is tegenwoordig de standaard wanneer men een draadveilige collectie nodig heeft (bijv. Set).
Synchroniseer ik het zelf, of is er een inherent veilige verzameling?
Antwoord 1, autoriteit 100%
Het .NET 4.0 Framework introduceert verschillende thread-safe collecties in de System.Collections.Concurrent Namespace:
ConcurrentBag<T>
Vertegenwoordigt een thread-safe, ongeordende verzameling objecten.ConcurrentDictionary<TKey, TValue>
Vertegenwoordigt een thread-veilige verzameling sleutel-waardeparen die door meerdere threads tegelijk kunnen worden geopend.ConcurrentQueue<T>
Vertegenwoordigt een thread-safe first in-first out (FIFO)-verzameling.ConcurrentStack<T>
Vertegenwoordigt een thread-safe last in-first out (LIFO) collectie.
Andere collecties in het .NET Framework zijn standaard niet thread-safe en moeten voor elke bewerking worden vergrendeld:
lock (mySet)
{
mySet.Add("Hello World");
}
Antwoord 2, autoriteit 17%
Pre .net 4.0 de meeste collecties in .Net zijn niet thread-safe. U moet zelf wat werk doen om de synchronisatie af te handelen: http://msdn .microsoft.com/en-us/library/573ths2x.aspx
Citaat uit artikel:
Collecties kunnen een thread worden gemaakt
veilig met een van de volgende:
methoden:Maak een draadveilige wikkel met de
Gesynchroniseerde methode, en toegang tot de
collectie uitsluitend via dat
wikkel.Als de klas geen heeft
Gesynchroniseerde methode, afgeleid van de
class en implementeer een Synchronized
methode met behulp van de eigenschap SyncRoot.Gebruik een vergrendelingsmechanisme, zoals de
lock-instructie in C# (SyncLock in
Visual Basic), op de SyncRoot
eigendom bij toegang tot de
collectie.
Synchronisatiehoofdeigenschap
Vergrendelingsverklaring
Object thisLock = new Object();
......
lock (thisLock)
{
// Critical code section
}
In .net 4.0 introduceerden de System.Collections.Concurrent naamruimte
Verzameling blokkeren
Gelijktijdige tas
Gelijktijdige wachtrij
Gelijktijdig woordenboek
Bestelbare partitie
Partitioner< br>
Partitioner T
Antwoord 3, autoriteit 4%
.NET 4 biedt een set thread-safe collecties onder System.Collections.Concurrent
Antwoord 4
In aanvulling op de zeer nuttige klassen in System.Collections.Concurrent, een standaardtechniek in scenario’s die meestal lezen en zelden veranderen (of als er echter frequente, maar niet-gelijktijdige schrijfbewerkingen zijn ) dat ook van toepassing is op .Net heet Copy-on-write.
Het heeft een aantal eigenschappen die wenselijk zijn in zeer gelijktijdige programma’s:
- instanties van verzamelingsobjecten zelf zijn onveranderlijk (d.w.z. thread-safe, kunnen veilig worden opgesomd zonder te vergrendelen)
- modificatie kan zoveel tijd kosten als het wil, de prestaties en gelijktijdigheid van leesbewerkingen worden niet beïnvloed
- kan generiek worden geïmplementeerdom elke datastructuur die niet thread-safe is om te zetten in een die dat wel is
Beperking: als er gelijktijdige schrijfbewerkingen zijn, moeten wijzigingen mogelijk opnieuw worden geprobeerd, dus hoe meer gelijktijdige schrijfbewerkingen, hoe minder efficiënt het wordt. (Dat is optimistische gelijktijdigheidop het werk)
BewerkenScott Chamberlain’s opmerking herinnerde me eraan dat er nog een beperking is: als uw gegevensstructuren enorm zijn en er vaak wijzigingen optreden, kan een alles-op-schrijven-kopie onbetaalbaar zijn, zowel wat betreft geheugengebruik en de bijbehorende CPU-kosten voor het kopiëren.