防止并行操作在顺序批处理中执行

Question

I have 8 logical processors. When executing the following code

public void test()
{
    Parallel.For(1, 1001, i => { IntensiveWork(i); });
}

private static void IntensiveWork(int i)
{
    Random r = new Random();
    Thread.Sleep(r.Next(i * 1));
}

I notice that the Parallel.For makes multiple batches of 8 jobs. Each batch will be executed sequentially. The issue in this is that if 7/8 jobs in the batch finished, then the next batch will keep waiting for the last job to finish. This means that 7 cores will not be busy. Is there a better way to implement parallelism is C#, in which once a job in the batch finishes it will assign that core another job.

Answer 1

You can make single queue that multiple tasks will read from.

static void test()
{
    ConcurrentQueue<int> queue = new ConcurrentQueue<int>(Enumerable.Range(1, 1000));
    int taskCount = Environment.ProcessorCount;
    Task[] tasks = new Task[taskCount];
    for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
    {
        Task task = Task.Factory.StartNew(() => IntensiveWorkTask(queue));
        tasks[taskIndex] = task;
    }
    Task.WaitAll(tasks);
}

private static void IntensiveWorkTask(ConcurrentQueue<int> queue)
{
    while (queue.TryDequeue(out int value))
        IntensiveWork(value);
}

private static void IntensiveWork(int i)
{
    Random r = new Random();
    Thread.Sleep(r.Next(i * 1));
}

Answer 2

Try Microsoft's Reactive Framework (aka Rx) - just NuGet System.Reactive and then add using System.Reactive.Linq; - then you can do this:

public void test()
{
    IObservable<Unit> query =
        Observable
            .Range(1, 1000)
            .SelectMany(i =>
                Observable
                    .Start(() => IntensiveWork(i)));

    IDisposable subscription = query.Subscribe();
}

private static Random r = new Random();

private static void IntensiveWork(int i)
{
    Thread.Sleep(r.Next(i * 1));
}

Play with the .Subscribe(... to be able to respond to each work item when it is completed.

Answer 3

Instead of:

Parallel.For(1, 1001, parallelOptions, i => IntensiveWork(i));

You should do:

IEnumerable<int> source = Enumerable.Range(1, 1000);

Partitioner<int> partitioner = Partitioner
    .Create(source, EnumerablePartitionerOptions.NoBuffering);
    
Parallel.ForEach(partitioner, parallelOptions, i => IntensiveWork(i));

The partitioning strategy of the Parallel.For is a combination of range partitioning and chunk partitioning, which is not appropriate for your case, and cannot be configured. What you want is a partitioner with load balancing behavior, with chunk partitioning disabled. That's why you have to switch to Parallel.ForEach , and configure the partitioner with the EnumerablePartitionerOptions.NoBuffering option.

The parallelOptions is shown below. It's always a good idea to specify explicitly the MaxDegreeOfParallelism , for example to Environment.ProcessorCount , instead of relying on the default -1 (unlimited) configuration that saturates the ThreadPool .

ParallelOptions parallelOptions = new()
{
    MaxDegreeOfParallelism = Environment.ProcessorCount
};