«Пулы блокировки» или другие решения для обработки операций с интенсивным использованием памяти в серверной части .NET Framework?

Если вам необходимо ограничить одновременное использование одного метода более чем одним, правильным классом потенциально будет SemaphoreSlim:

Представляет облегченную альтернативу Semaphore, которая ограничивает количество потоков, которые могут одновременно обращаться к ресурсу или пулу ресурсов.

Прямо из упомянутой документации приведен пример того, как можно ограничить максимальное количество одновременных задач, которые будут выполнять действие:

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    private static SemaphoreSlim semaphore;
    // A padding interval to make the output more orderly.
    private static int padding;

    public static void Main()
    {
        // Create the semaphore.
        semaphore = new SemaphoreSlim(0, 3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        Task[] tasks = new Task[5];

        // Create and start five numbered tasks.
        for (int i = 0; i <= 4; i++)
        {
            tasks[i] = Task.Run(() =>
            {
                // Each task begins by requesting the semaphore.
                Console.WriteLine("Task {0} begins and waits for the semaphore.",
                                  Task.CurrentId);
                
                int semaphoreCount;
                semaphore.Wait();
                try
                {
                    Interlocked.Add(ref padding, 100);

                    Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId);

                    // The task just sleeps for 1+ seconds.
                    Thread.Sleep(1000 + padding);
                }
                finally {
                    semaphoreCount = semaphore.Release();
                }
                Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.",
                                  Task.CurrentId, semaphoreCount);
            });
        }

        // Wait for half a second, to allow all the tasks to start and block.
        Thread.Sleep(500);

        // Restore the semaphore count to its maximum value.
        Console.Write("Main thread calls Release(3) --> ");
        semaphore.Release(3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        // Main thread waits for the tasks to complete.
        Task.WaitAll(tasks);

        Console.WriteLine("Main thread exits.");
    }
}
// The example displays output like the following:
//       0 tasks can enter the semaphore.
//       Task 1 begins and waits for the semaphore.
//       Task 5 begins and waits for the semaphore.
//       Task 2 begins and waits for the semaphore.
//       Task 4 begins and waits for the semaphore.
//       Task 3 begins and waits for the semaphore.
//       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
//       Task 4 enters the semaphore.
//       Task 1 enters the semaphore.
//       Task 3 enters the semaphore.
//       Task 4 releases the semaphore; previous count: 0.
//       Task 2 enters the semaphore.
//       Task 1 releases the semaphore; previous count: 0.
//       Task 3 releases the semaphore; previous count: 0.
//       Task 5 enters the semaphore.
//       Task 2 releases the semaphore; previous count: 1.
//       Task 5 releases the semaphore; previous count: 2.
//       Main thread exits.

Основываясь на ответе Оливера, я на данный момент остановился на следующем решении:

private readonly SemaphoreSlim Semaphore = new SemaphoreSlim(3, 3);
private readonly ThreadLocal<bool> SemaphoreHeld = new ThreadLocal<bool>(() => false);

public byte[] TransformImage(byte[] imageBytes)
{
    AcquireSemaphore();
    try
    {
        // Do memory intensive work
    }
    finally
    {
        ReleaseSemaphore();
    }
}

private void AcquireSemaphore()
{
    if (!SemaphoreHeld.Value)
    {
        Semaphore.Wait();
        SemaphoreHeld.Value = true;
    }
}

private void ReleaseSemaphore()
{
    if (SemaphoreHeld.Value)
    {
        Semaphore.Release();
        SemaphoreHeld.Value = false;
    }
}

В некоторых методах я вызываю другие функции, которые получают тот же семафор. Использование ThreadLocal позволяет мне проверить, получил ли текущий поток его уже, а затем пропустить его повторное получение.

Одно из расширений, которое я мог бы включить в будущем, — это установка количества доступных семафоров в соответствии с доступной памятью.