Sie haben eine Reihe von Aufgaben mit nur X zu einem Zeitpunkt ausgeführt

Sagen wir mal ich habe 100 Aufgaben, die etwas tun, was nur 10 Sekunden dauert.
Jetzt möchte ich nur ausführen, 10 in einer Zeit wie bei 1 der 10-Platzierungen ein weiterer task wird ausgeführt, bis alle fertig sind.

Jetzt habe ich immer verwendet ThreadPool.QueueUserWorkItem() für eine solche Aufgabe, aber ich habe gelesen, dass es schlechte Praxis ist dies zu tun und dass ich verwenden soll Aufgaben statt.

Mein problem ist, dass ich nirgends zu finden ist ein gutes Beispiel für mein Szenario, so könnten Sie get begann mich wie Sie zu erreichen ist dieses Ziel mit Aufgaben?

Wo hast du gelesen, dass die Verwendung der ThreadPool war eine schlechte Praxis?
Ich würde vorschlagen, einige Artikel gelesen und oder vorherigen Stackoverflow-Beiträge gibt es reichlich codiert Beispiele, dass andere versucht haben und wo Antworten sind, sofern Sie die stackoverflow.com/questions/6192898/... eine google-Suche, wie ich über C# Stackoverflow-ThreadPool.QueueUserWorkItem()
Wollen Sie eine Methode blockiert, bis alle Aufgaben fertig sind, oder wollen Sie eine Methode, die zurückgibt einen Task wenn alle Aufgaben erledigt sind?
Es sollte block, genau wie ThreadPool funktioniert aber mit Aufgaben. Einige Leute hier bei Stackoverflow erzählte mir ein code-Beispiel, das Threadpool-schlechte Praxis

InformationsquelleAutor maddo7 | 2012-12-28

  1. 32
    SemaphoreSlim maxThread = new SemaphoreSlim(10);

for (int i = 0; i < 115; i++)
{
    maxThread.Wait();
    Task.Factory.StartNew(() =>
        {
            //Your Works
        }
        , TaskCreationOptions.LongRunning)
    .ContinueWith( (task) => maxThread.Release() );
}
    Warum gibst du TaskCreationOptions.LongRunning?
    Ich würde empfehlen, mit dem Semaphore-Klasse statt SemaphoreSlim, wenn Ihre Aufgabe ist vorgesehen, um eine lange laufende Aufgabe.
    Ich kann etwas fehlt, aber ich sehe nur einen Haupt-thread ausgeführt, die Schleife und die Arbeiter(10) ausgeführt in der gleichen Zeit.. Die blockiert ist der Haupt-thread(1)
    Ich bitte um Entschuldigung; ich habe falsch gelesen die Lage der warte - my bad - ich lese in Eile, und irren würde
    So fügen Sie eine neue Aufgabe in die Warteschlange, wenn eine Aufgabe 10 Aufgabe wurde abgeschlossen. Bedeutet das hinzufügen einer neuen task in der Warteschlange. Hier mein Ziel ist zum Beispiel, wenn wir schon ein limit von 10 tasks in einer einzelnen Zeit durch SemaphoreSlim oder MaxDegreeOfParallelism aber ich will nicht zu 100 Aufgabe und legen Sie dann die Grenze von SemaphoreSlim oder MaxDegreeOfParallelism und Steuern Sie Sie ausführen 10 auf ein einziges mal. Ich will nur, um eine neue Aufgabe zu erstellen, wenn eine Aufgabe abgeschlossen von 10 Aufgabe und dieser Prozess wird unendlich fortgesetzt.

    InformationsquelleAutor L.B

  2. 15

    TPL Dataflow ist ideal für Dinge wie diese. Sie können erstellen, eine 100% - async-version von Parallel.Invoke ziemlich einfach:

    async Task ProcessTenAtOnce<T>(IEnumerable<T> items, Func<T, Task> func)
{
    ExecutionDataflowBlockOptions edfbo = new ExecutionDataflowBlockOptions
    {
         MaxDegreeOfParallelism = 10
    };

    ActionBlock<T> ab = new ActionBlock<T>(func, edfbo);

    foreach (T item in items)
    {
         await ab.SendAsync(item);
    }

    ab.Complete();
    await ab.Completion;
}
    Genau das, was ich suchte, danke!
    die TPL dataflow library ist wirklich super cool und ich habe bereits eine Verwendung für Sie, danke für den Hinweis it out
    das ist ein großer Ansatz, ist es möglich, es zu machen, zurück aber? - Ich bin am überlegen, es zu benutzen, um einen Dienst aufrufen, das dauert eine Weile bis zur Antwort.
    dies ist nur ein winziger Teil von dem, was TPL Dataflow tun können. Sie können möglicherweise verwenden Sie eine TransformBlock für das, was Sie wollen.
    Die nuget für TPL Dataflow wurde jetzt nicht angeführt. Es wurde ersetzt mit "System".Threading.Aufgaben.Dataflow

    InformationsquelleAutor Cory Nelson

  3. 9

    Haben Sie mehrere Möglichkeiten. Sie können Parallel.Invoke für den Anfang:

    public void DoWork(IEnumerable<Action> actions)
{
    Parallel.Invoke(new ParallelOptions() { MaxDegreeOfParallelism = 10 }
        , actions.ToArray());
}

    Hier ist eine Alternative option, die Arbeit wird sehr viel schwieriger zu haben, genau 10 Aufgaben ausgeführt werden (obwohl die Anzahl der threads im thread-pool der Bearbeitung dieser Aufgaben kann unterschiedlich sein) und gibt eine Task anzeigt, wenn es fertig ist, anstatt zu blockieren, bis getan.

    public Task DoWork(IList<Action> actions)
{
    List<Task> tasks = new List<Task>();
    int numWorkers = 10;
    int batchSize = (int)Math.Ceiling(actions.Count / (double)numWorkers);
    foreach (var batch in actions.Batch(actions.Count / 10))
    {
        tasks.Add(Task.Factory.StartNew(() =>
        {
            foreach (var action in batch)
            {
                action();
            }
        }));
    }

    return Task.WhenAll(tasks);
}

    Wenn Sie nicht über MoreLinq, für die Batch Funktion, hier ist meine einfachere Umsetzung:

    public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
{
    List<T> buffer = new List<T>(batchSize);

    foreach (T item in source)
    {
        buffer.Add(item);

        if (buffer.Count >= batchSize)
        {
            yield return buffer;
            buffer = new List<T>();
        }
    }
    if (buffer.Count >= 0)
    {
        yield return buffer;
    }
}
    Now I want to only run 10 at a time, MaxDegreeOfParallelism ist nur eine Obere Schranke.
    Nun, technisch gesehen, wenn die Anzahl der Einheiten der Arbeit ist nicht durch 10 teilbar, dann genau ten, ist nicht möglich.
    Nein, auch mit 100 funktioniert, kann es am Ende läuft weniger Aufgaben. Es hängt von vielen Parametern wie Anzahl der CPUs
    Ich bin mir dessen bewusst, dass. Ich war besagt, dass selbst wenn Sie versucht, näher zu sein genau 10 man kann nicht immer perfekt sein, Sie können nur...näher.
    Geht eine zusätzliche version, die ich Hinzugefügt, die Sie erfüllen?

    InformationsquelleAutor Servy

  4. 5

    Ich würde gerne die einfachste Lösung, die ich denken kann, die, wie ich denke, mit der TPL:

    string[] urls={};
Parallel.ForEach(urls, new ParallelOptions() { MaxDegreeOfParallelism = 2}, url =>
{
   //Download the content or do whatever you want with each URL
});

    InformationsquelleAutor Samer Abu Rabie

  5. 2

    Können Sie eine Methode erstellen, wie diese:

    public static async Task RunLimitedNumberAtATime<T>(int numberOfTasksConcurrent, 
    IEnumerable<T> inputList, Func<T, Task> asyncFunc)
{
    Queue<T> inputQueue = new Queue<T>(inputList);
    List<Task> runningTasks = new List<Task>(numberOfTasksConcurrent);
    for (int i = 0; i < numberOfTasksConcurrent && inputQueue.Count > 0; i++)
        runningTasks.Add(asyncFunc(inputQueue.Dequeue()));

    while (inputQueue.Count > 0)
    {
        Task task = await Task.WhenAny(runningTasks);
        runningTasks.Remove(task);
        runningTasks.Add(asyncFunc(inputQueue.Dequeue()));
    }

    await Task.WhenAll(runningTasks);
}

    Und dann kann man rufen jede async-Methode n-mal mit einem limit, wie diese:

    Task task = RunLimitedNumberAtATime(10,
    Enumerable.Range(1, 100),
    async x =>
    {
        Console.WriteLine($"Starting task {x}");
        await Task.Delay(100);
        Console.WriteLine($"Finishing task {x}");
    });

    Oder wenn Sie wollen, zu laufen, lange laufen, nicht async-Methoden, die Sie tun können, es auf diese Weise:

    Task task = RunLimitedNumberAtATime(10,
    Enumerable.Range(1, 100),
    x => Task.Factory.StartNew(() => {
        Console.WriteLine($"Starting task {x}");
        System.Threading.Thread.Sleep(100);
        Console.WriteLine($"Finishing task {x}");
    }, TaskCreationOptions.LongRunning));

    Vielleicht gibt es eine ähnliche Methode irgendwo im Rahmen, aber ich habe nicht es noch.

    InformationsquelleAutor Matthias Auswöger

Schreibe einen Kommentar