Wie keine Anzahl von Threads (z. B. 128) in C# Console Application parallel ausgeführt werden?

Question

Der Versuch, seit ein paar Wochen fertig zu werden, aber viele Suchen und Ausprobieren der meisten Logik, passiert nicht.

Szenario: Ich möchte ein Programm ausführen, das einige Aufgaben (async) hat sagen wir 128 (möglicherweise größer) was ich will, dass jede Aufgabe einen neuen Thread aus Thread-Pool verwendet.

Sagen wir, es gibt 500 Aufgaben, die jeweils einzelne Thread von Systemressource verwendet. alle laufen parallel, d.h. sie hängen überhaupt nicht voneinander ab.

Vielen Dank im Voraus.

Ich schätze wirklich Hilfe, die von Ihnen zur Verfügung gestellt wird.

Answer 1

In einer Konsolenanwendung können Sie Async-Methoden nicht direkt verwenden, verwenden Sie die AsyncContext, die von https://www.nuget.org/packages/Nito.AsyncEx bereitgestellt wird.

Dann können Sie Aufgaben erstellen und sie asynchron ausführen

class Program 
{ 
    static void Main(string[] args) 
    { 
     //use AsyncContext, provided by the Nito.AsyncEx library 
     AsyncContext.Run(() => MainAsync(args)); 
    } 

    static async void MainAsync(string[] args) 
    { 
     var taskList = new List<Task>(); 
     for (int i = 0; i < 128; i++) 
     { 
      //add the new Task to the list and start to execute it 
      taskList.add(DoStuffAsync()); 
     } 

     //wait for all to finish 
     await Task.WhenAll(taskList); 
    } 

    private static async Task DoStuffAsync() 
    { 
     //do async stuff, like download from webpage 
    } 
} 

Answer 2

Es scheint, dass Sie mehrere Aufgaben, die von mehreren Threads ausführen möchten. Async-Await soll einen Thread andere Dinge tun lassen, während er warten muss, bis etwas fertig ist.

Etwas, das mir half zu verstehen, warum und wann Sie async-erwarten sollten, war this interview with Eric Lippert Suchen Sie irgendwo in der Mitte für Async erwarten.

Eine andere Sache, die mich verstehen Asynchron-await half war this article by the ever so helpful Stephen Cleary

Wenn die Fäden Sie nicht haben, etwas Nützliches zu tun, während sie auf etwas warten starten gehen, können Sie sie starten nutzen könnten:

static class Program 
{ 
    static void Main(string[] args) 
    { 
     List<Task> runningTasks = new List<Task>(); 
     IEnumerable<Action> thingsToDo = GetThingsToDo() 
     foreach (Action thingToDo in thingsToDo) 
     { 
      Task startedTask = Task.Run(() => thingToDo); 
      runningTasks.Add(startedTask); 
     } 
     // now that all tasks are started do something else 
     // after a while wait until all tasks finished 
     Task.WaitAll(runningTasks.ToArray()); 
    } 
} 

Nur wenn ein Thread, der eine Ihrer Aktionen ausführt, etwas Sinnvolles tun kann, während Sie auf etwas in der Aktion warten, sollten Sie Ihre Aktionen als async und Task.Run (async() => erwarten. ..)

Aber auch dann muss Ihr Haupt-Thread nicht in einer erwarteten Funktion sein. Nach dem Start aller anderen Threads ist es immer noch frei, zu tun, was immer es tun möchte.