est la File d'attente.Synchronisé plus rapide que l'utilisation d'un Verrou()?

Lors de la demande de Queue.Synchonized vous obtenez un SynchronizedQueue en retour qui utilise un lock très peu autour des appels à Enqueue et Dequeue sur l'intérieure de la file d'attente. Par conséquent, la performance devrait être la même que l'utilisation d'un Queue et de la gestion de verrouillage-vous pour Enqueue et Dequeue avec votre propre lock.

Vous êtes en effet imaginer des choses - qu'ils doivent être la même.

Mise à jour

Il est d'ailleurs le fait que lors de l'utilisation d'un SynchronizedQueue vous ajoutez une couche d'indirection que vous devez passer par le wrapper méthodes pour obtenir à l'intérieur de la file d'attente dont il est le directeur. Si quelque chose de ce qui devrait ralentir les choses très très légèrement plus que vous avez une trame supplémentaire sur la pile qui doit être géré pour chaque appel. Dieu sait si dans-doublure annule ce sort bien. C'est là minimale.

Mise à jour 2

J'ai maintenant comparé à cela, et comme prévu dans ma précédente mise à jour:

"File d'attente.Synchronisé" est plus lente que la "File d'attente+lock"

J'ai réalisé un single-threaded test comme ils utilisent la même technique de verrouillage (c'est à dire lock) donc, les tests pur frais généraux dans une "ligne droite" semble raisonnable.

Ma référence produit les résultats suivants pour un Libération construire:

Iterations      :10,000,000

Queue+Lock      :539.14ms
Queue+Lock      :540.55ms
Queue+Lock      :539.46ms
Queue+Lock      :540.46ms
Queue+Lock      :539.75ms
SynchonizedQueue:578.67ms
SynchonizedQueue:585.04ms
SynchonizedQueue:580.22ms
SynchonizedQueue:578.35ms
SynchonizedQueue:578.57ms

En utilisant le code suivant:

private readonly object _syncObj = new object();
[Test]
public object measure_queue_locking_performance()
{
const int TestIterations = 5;
const int Iterations = (10 * 1000 * 1000);
Action<string, Action> time = (name, test) =>
{
for (int i = 0; i < TestIterations; i++)
{
TimeSpan elapsed = TimeTest(test, Iterations);
Console.WriteLine("{0}:{1:F2}ms", name, elapsed.TotalMilliseconds);
}
};
object itemOut, itemIn = new object();
Queue queue = new Queue();
Queue syncQueue = Queue.Synchronized(queue);
Action test1 = () =>
{
lock (_syncObj) queue.Enqueue(itemIn);
lock (_syncObj) itemOut = queue.Dequeue();
};
Action test2 = () =>
{
syncQueue.Enqueue(itemIn);
itemOut = syncQueue.Dequeue();
};
Console.WriteLine("Iterations:{0:0,0}\r\n", Iterations);
time("Queue+Lock", test1);
time("SynchonizedQueue", test2);
return itemOut;
}
[SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.GC.Collect")]
private static TimeSpan TimeTest(Action action, int iterations)
{
Action gc = () =>
{
GC.Collect();
GC.WaitForFullGCComplete();
};
Action empty = () => { };
Stopwatch stopwatch1 = Stopwatch.StartNew();
for (int j = 0; j < iterations; j++)
{
empty();
}
TimeSpan loopElapsed = stopwatch1.Elapsed;
gc();
action(); //JIT
action(); //Optimize
Stopwatch stopwatch2 = Stopwatch.StartNew();
for (int j = 0; j < iterations; j++) action();
gc();
TimeSpan testElapsed = stopwatch2.Elapsed;
return (testElapsed - loopElapsed);
}

OriginalL'auteur Tim Lloyd

1. File d'attente.Synchroniser Enroule une nouvelle file d'attente Synchronisé tout bloquer la File d'attente.SyncRoot donne un Objet pour accéder à la File d'attente de manière synchronisée ainsi, de cette façon vous pouvez vous assurer de la Sécurité des Threads dans la File d'attente tout en utilisant les opérations de mise en File d'attente et de Résorption de l'simultanément à l'aide de Threads.

OriginalL'auteur Vishal Patwardhan