Leistungszähler werden inkorrekt erhöht?

Question

Ein wahrscheinlicher Anfängerfehler, aber ich bekomme etwas Seltsames. ich versuche, einen .NET-Leistungsindikator in eine Anwendung einzuflechten.

Wenn ich die Methode incrementBy(value) auf meinen Durchschnittsleistungsindikator aufrufe, ändert sich auch der RawValue meines Basenindikators um den Wert. Ich habe die Variablennamen überprüft und denke, dass alles korrekt ist.

Dann, wenn ich increment() auf meinem Basenindikator aufrufe, fügt es auch 1 zum RawValue des Durchschnittsindikators hinzu und erhöht gleichzeitig den Basenindikator... das setzt dem Ganzen die Krone auf!

Hat jemand schon einmal ein solches Verhalten gesehen? Irgendwelche Vorschläge, was hier vor sich geht und wie man das beheben kann?

In meinem Code verwende ich zwei verschiedene Zähler, um die Zeit zu messen, die ein von mir geschriebener Merge-Sort benötigt. Ich habe einen Instantanzähler für die vergangene Zeit des Sortierens und einen Durchschnittszähler.

Dim timePiece As New Stopwatch()

timePiece.Start()
MergeSort()
timePiece.Stop()

ElapsedCounter.RawValue = timePiece.ElapsedMilliseconds
AvgCounter.IncrementBy(timePiece.ElapsedMilliseconds)
AvgCounterBase.Increment()

Was ich beobachte ist:

'Der vergangene Zähler funktioniert wie erwartet
'Der AvgCounter RawValue beträgt 7, der AvgCounterBase RawValue beträgt ebenfalls 7, bevor sie inkrementiert wurden

 AvgCounter.IncrementBy(value) 'AvgCounter.RV ist 7+wert, AvgCounterBase ist 7+wert   
 AvgCounterBase.Increment()    'AvgCounter.RV ist 7+wert+1, AvgCounterBase ist 7+wert+1  

Ich denke, ich verwende die Zähler falsch, aber warum ändert sich der RawValue des Durchschnitts, wenn ich den des Basen ändere? Das sollte meiner Meinung nach nicht passieren.

Answer 1

Dieses Verhalten ist so, wie es funktionieren sollte. Increment und IncrementBy sind im Grunde genommen thread-sichere Versionen von dem, was du selbst tun könntest, indem du RawValue direkt modifizierst. Wenn der Zähler nur von einem einzigen Thread zugegriffen wird, sind diese Anweisungen:

counterVariable.RawValue++;
counterVariable.RawValue += 2;

äquivalent zu diesen Anweisungen:

counterVariable.Increment();
counterVariable.IncrementBy(2);

Wenn von mehreren Threads zugegriffen wird, ist das direkte Modifizieren von RawValue nicht thread-sicher und kann möglicherweise einige der Updates verlieren.