如何执行“ Parallel.ForEach”作为后台任务，将控制立即返回到调用方法？

Question

如何执行“ Parallel.ForEach”作为后台任务，该任务将立即将控制权返回给调用方法？

我想使用C＃/ Linq“ Parallel.Foreach”，但我不想一直等到所有并行任务都完成后才能继续执行call方法中的下一条语句。 我正在寻找一种从另一个线程异步处理“ Parallel.Foreach”完成的方法。

using System.Threading.Tasks;
using System.Collections.Concurrent;

public class stuff {    
    int[]                jobs;
    ConcurrentQueue<int> done;

    void DoSomething(int job_id) {
       //This takes a long time...
       Sleep(10000);
    }

    void Button_Click() {
        jobs = new int[] {0,20,10,13,12};

        // parallel.foreach...ok great...now all CPUs will 
        // be loaded in parallel with tasks... 
        // … But, How to get this to return 
        // immediately without awaiting completion?
        Parallel.ForEach(jobs, job_i => {
            DoSomething(job_i);
            done.Enqueue(job_i); //tell other thread that job is done
        });
        // now my gui is blocked and unresponsive until this 
        // foreach fully completes...instead, 
        // I want this running in background and returning immediately to gui
        // so that its not hung...
    }
 }

Answer 1

对于初学者来说，我建议使用async void EventHandler 。

具有await方法的async eventhandler处理程序将防止冻结UI /主线程。 要受益于上述异步性，您将需要在代码中进行异步/等待。

建议对此进行更改：

void Button_Click() {
    jobs = new int[] {0,20,10,13,12};

    // parallel.foreach...ok great...now all CPUs will 
    // be loaded in parallel with tasks... 
    // … But, How to get this to return 
    // immediately without awaiting completion?
    Parallel.ForEach(jobs, job_i => {
        DoSomething(job_i);
        done.Enqueue(job_i); //tell other thread that job is done
    });
    // now my gui is blocked and unresponsive until this 
    // foreach fully completes...instead, 
    // I want this running in background and returning immediately to gui
    // so that its not hung...
}

为此：

    public async void Button_Click()
    {
        await DoMyWorkAsync();
    }

    private async Task DoMyWorkAsync()
    {
        await Task.Run(() =>
        {
            jobs = new int[] { 0, 20, 10, 13, 12 };

            Parallel.ForEach(jobs, job_i =>
            {
                DoSomething(job_i);
                done.Enqueue(job_i);
            });
        });
    }

注意：可能还有其他注意事项，例如，有人双击。 但是，要回答原始问题-这应该是您需要的所有更改。 请参阅下面的快速而肮脏的ThreadSafeBoolean。

对于TAP / C＃纯粹主义者：
如果Toub，Cleary或Skeet在这里，他们会警告我不要使用await任务包装器-但是，我发现在现实世界中，要保持Async / Await模式-偶尔需要这种模式。 即使Parallel也支持异步lambda，其行为也是无法预料的。 您将需要类似Yuri的NitroEx或ForEachAsync扩展。 但是，如果您想运行类似这些同步触发的操作，并且并行和异步地忘记了-异步任务包装器通常是最简单的解决方案。

下面，我将演示如何使用由Interlocked支持的线程安全布尔值来处理双击。 对于更具可读性/通用性的代码，我还将考虑if (Monitor.TryEnter(myObjectLock, 0))或SemaphoreSlim(1,1) 。 每个人都有不同的使用方式。 如果我坚持这种情况的模式，那么Monitor.TryEnter也许是最干净的方法，因为它将返回false，并且您可以退出，类似于线程安全布尔。 为了提高效率和简化性，我假设如果事件已经运行，我们将仅通过它（即不执行任何操作）。

带有Threadsafe布尔值的示例繁忙检查：

using System.Threading;

// default is false, set 1 for true.
private static int _threadSafeBoolBackValue = 0;

public bool ThreadSafeBusy
{
    get { return (Interlocked.CompareExchange(ref _threadSafeBoolBackValue, 1, 1) == 1); }
    set
    {
        if (value) Interlocked.CompareExchange(ref _threadSafeBoolBackValue, 1, 0);
        else Interlocked.CompareExchange(ref _threadSafeBoolBackValue, 0, 1);
    }
}

public async void Button_Click(object sender, EventArgs e)
{
    if (!ThreadSafeBusy)
    {
        ThreadSafeBusy = true;
        await DoMyWorkAsync();
        ThreadSafeBusy = false;
    }
}

private async Task DoMyWorkAsync()
{
    await Task.Run(() =>
    {
        jobs = new int[] { 0, 20, 10, 13, 12 };

        Parallel.ForEach(jobs, job_i =>
        {
            DoSomething(job_i);
            done.Enqueue(job_i);
        });
    });
}

对于其他性能优化，请考虑并发插入的替代方法，如果工作量很大，请将并行处理的并行foreach限制为new ParallelOptions {MaxDegreeOfParallelism = Environment.ProcessorCount} 。

private async Task DoMyWorkAsync()
{
    await Task.Run(() =>
    {
        jobs = new int[] { 0, 20, 10, 13, 12 };

        Parallel.ForEach(
            parallelOptions: new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
            source: jobs,
            body: job_i =>
            {
                DoSomething(job_i);
                done.Enqueue(job_i);
            });
    });
}

Answer 2

您可以在单独的任务中运行Parallel.ForEach，并在完成所有任务后调用委托：

int[] jobs;
ConcurrentQueue<int> done = new  ConcurrentQueue<int>();

jobs = new int[] {0, 20, 10, 13, 12};

//How to get this to return immediately without awaiting completion?
Task tsk = new TaskFactory().StartNew(() =>
    {
        Parallel.ForEach(jobs, jobI =>
        {
            DoSomething(jobI);

            done.Enqueue(jobI);
        });
    })
    .ContinueWith(task =>
    {
        MessageBox.Show("Parallel.ForEach complete");
    });

Answer 3

方法1：

var thread = new Thread(() => {
    //JobInit();
    Parallel.ForEach(jobs, job_i => {
        DoSomething(job_i);
        done.Enqueue(job_i);
    });
    //stop = true;
});

thread.Start();
//stop = false;

方法2：

bool run_task() {        
    Parallel.ForEach(jobs, job_i => {
        DoSomething(job_i);
        done.Enqueue(job_i);
    });
    return true;
}

void Button_click() {

    // save task variable to run in background
    Task.Run(() => { run_task() });
}

笔记：

（但是，由于某种原因，我发现parallel.foreach为每个启动的任务插入的开销非常高。。似乎它同时启动了太多的工作任务，并且它们在同一个cpu上争夺有限的资源。 ..最终变得比另一种情况要慢，在这种情况下，我并行启动了4个任务，然后等待所有任务完成，然后再获得另一批4个并行任务...这种使用情况在每次通过时限制了4个任务的并行批处理大型阵列要快得多...）