Auslastungstest mit C# Async Warten

Question

Ich erstelle ein Konsolenprogramm, das Lesen/Schreiben in einen Cache testen kann, indem es mehrere Clients simuliert und folgenden Code geschrieben hat. Bitte helfen Sie mir zu verstehen:

• Ist es richtig Weg, um die Multi-Client-Simulation
• Was kann ich mehr es dich um einen echten Belastungstest

void Main() 
{ 

    List<Task<long>> taskList = new List<Task<long>>(); 

    for (int i = 0; i < 500; i++) 
    { 
     taskList.Add(TestAsync()); 
    } 

    Task.WaitAll(taskList.ToArray()); 

    long averageTime = taskList.Average(t => t.Result); 

} 

public static async Task<long> TestAsync() 
{ 
    // Returns the total time taken using Stop Watch in the same module 
    return await Task.Factory.StartNew(() => // Call Cache Read/Write); 
} 

Answer 1

Bereinigt um Ihren Code zu tun, um zu erreichen leicht zu sehen, wie viele Threads wir zu einer bestimmten Zeit haben.

static volatile int currentExecutionCount = 0; 

static void Main(string[] args) 
{ 
    List<Task<long>> taskList = new List<Task<long>>(); 
    var timer = new Timer(Print, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)); 

    for (int i = 0; i < 1000; i++) 
    { 
     taskList.Add(DoMagic()); 
    } 

    Task.WaitAll(taskList.ToArray()); 

    timer.Change(Timeout.Infinite, Timeout.Infinite); 
    timer = null; 

    //to check that we have all the threads executed 
    Console.WriteLine("Done " + taskList.Sum(t => t.Result)); 
    Console.ReadLine(); 
} 

static void Print(object state) 
{ 
    Console.WriteLine(currentExecutionCount); 
} 

static async Task<long> DoMagic() 
{ 
    return await Task.Factory.StartNew(() => 
    { 
     Interlocked.Increment(ref currentExecutionCount); 
     //place your code here 
     Thread.Sleep(TimeSpan.FromMilliseconds(1000)); 
     Interlocked.Decrement(ref currentExecutionCount); 
     return 4; 
    } 
    //this thing should give a hint to scheduller to use new threads and not scheduled 
    , TaskCreationOptions.LongRunning 
    ); 
} 

Das Ergebnis ist: in einer virtuellen Maschine, die ich von 2 bis 10 Threads gleichzeitig ausgeführt werden, wenn ich den Hinweis nicht verwenden. Mit dem Hinweis - bis zu 100. Und auf der realen Maschine kann ich 1000 Fäden gleichzeitig sehen. Process Explorer bestätigt dies. Einige Details zum hint wären hilfreich.

Answer 2

Wenn es sehr beschäftigt ist, dann müssen Ihre Kunden anscheinend eine Weile warten, bevor ihre Anfragen bearbeitet werden. Ihr Programm misst dies nicht, da Ihre Stoppuhr startet, wenn die Serviceanfrage beginnt.

Wenn Sie auch messen möchten, was mit der durchschnittlichen Zeit vor dem Ende einer Anfrage geschieht, sollten Sie Ihre Stoppuhr starten, wenn die Anfrage gestellt wird, nicht wenn die Anfrage bearbeitet wird.

Ihr Programm nimmt nur Threads aus dem Thread-Pool. Wenn Sie mehr Aufgaben starten, als es Threads gibt, müssen einige Aufgaben warten, bevor TestAsync gestartet wird. Diese Wartezeit wird gemessen, wenn Sie sich daran erinnern, dass Task.Run aufgerufen wurde.

Neben dem Fehler bei den Zeitmessungen, wie viele Serviceanfragen erwarten Sie gleichzeitig? Gibt es genügend freie Threads in Ihrem Thread-Pool, um dies zu simulieren? Wenn Sie etwa 50 Serviceanforderungen zur gleichen Zeit erwarten und die Größe Ihres Threadpools nur 20 Threads beträgt, werden nie 50 Serviceanforderungen gleichzeitig ausgeführt. Umgekehrt: Wenn Ihr Thread-Pool viel größer ist als die Anzahl der erwarteten gleichzeitigen Serviceanforderungen, werden Sie längere Zeiten messen, als dies tatsächlich der Fall ist.

Sie können die Anzahl der Threads in Ihrem Thread-Pool ändern und sicherstellen, dass niemand sonst Threads des Pools verwendet.