Использование миллионов Task-ов приводит к ошибке System.OutOfMemoryException (C#)

Давайте попробуем этот код стабилизировать

• нужно избавиться от лишних делегатов
• нет смысла гонять файловую систему из кучи потоков, она синхронная, она не может в рамках одного носителя выполнять кучу операций одновременно
• нет смысла трогать настройки пула потоков, он нормально настроен, просто нужно относиться к нему бережно
• нельзя блокировать поток контроллера, так вы вешаете весь сервер, для этого есть асинхронные операции
• много локов - плохо для понимания кода и производительности, используйте потокобезопасные коллекции
• процедура чтения int переменной атомарна сама по себе, поэтому lock не нужен для чтения, избавиться от лишних локов
• полностью избавиться от статики
• ограничить количество одновременно работающих задач до количества ядер сервера, умноженное на два (так исторически сложилось, что это оптимально, с этого надо начинать)
• каждый созданный вами Task должен быть ожидаемым, так вы получаете контроль над процессом и удобнее ловить исключения
• удаление файлов можно вообще через Producer/Consumer сделать, чтобы удалялись сразу как появляются в череди на удаление, при этом не тормозили основной код.

Вот и получается как-то так

[HttpPost("ImportSignatures")]
public async Task<JsonResult> ImportSignatures()
{
    SignatureImportService importService = new SignatureImportService();
    try
    {
        ImportSigningCertsResult res = await importService.ImportSigningCerts();
        return Json(res);
    }
    catch (Exception e)
    {
        LogsHelper.WriteLog("api/Settings/ImportSignatures", e);
        return Json(new ImportSigningCertsResult(e.Message, importService.WasCancelled));
    }
}

public async Task<ImportSigningCertsResult> ImportSigningCerts()
{
    LogsHelper.WriteEventLog("Запуск SignatureImportService");

    const string cancelMsg = "Импорт сертификатов был прерван. \n";
    const string endMsg = "Импорт сертификатов успешно завершён. \n";
    try
    {
        using (_cts = new CancellationTokenSource())
        {
            var configuration = SignatureImportConfiguration.FromCfg();
            string[] signatures = Directory.GetFiles(configuration.Path, "*.sig");
            totalSignatures = signatures.Length;
            processedSignatures = 0;

            Store mainStore = StoreMan.GetStore("Main");
            var importStats = new ImportStats();
            List<Task> tasks = new();

            int saveIndex = 1;
            const int proccessedForSave = 100000; // Через какое кол-во обработанных подписей произвести промежуточное сохранение хранилища и удаление подписей
            CancellationToken token = _cts.Token;
            Channel<string> channel = Channel.CreateUnbounded<string>();
            ChannelWriter<string> deleteQueue = channel.Writer;
            Task deleteTask = DeleteWorkerAsync(channel.Reader, token);
            object saveSync = new object();
            int maxJobs = Environment.ProcessorCount * 2;
            using SemaphoreSlim semaphore = new(maxJobs);
            try
            {
                foreach (string path in signatures)
                {
                    await semaphore.WaitAsync(token);
                    if (tasks.Count > maxJobs * 2)
                    {
                        for (int i = 0; i < tasks.Count; i++) // не позволит списку тасков расти бесконечно
                        {
                            if (tasks[i].IsCompletedSuccessfully)
                            {
                                tasks.RemoveAt(i--);
                            }
                        }
                    }
                    tasks.Add(Task.Run(() =>
                    {
                        try
                        {
                            token.ThrowIfCancellationRequested();

                            if (UploadSigningCerts(mainStore, path, importStats) && configuration.NeedCleaning)
                            {
                                deleteQueue.TryWrite(path);
                            }
                            bool needSave = false;
                            lock (saveSync)
                            {
                                if (++processedSignatures > proccessedForSave * saveIndex)
                                {
                                    saveIndex++;
                                    needSave = true;
                                }
                            }
                            if (needSave)
                            {
                                LogsHelper.WriteEventLog("Промежуточное сохранение хранилища сертификатов...");
                                mainStore.WriteIfChanged();
                            }
                        }
                        catch (Exception e) when (e is not OperationCanceledException)
                        {
                            LogsHelper.WriteLog("SignatureImportService/ImportSigningCerts:Task.Factory.StartNew", e);
                        }
                        finally
                        {
                            semaphore.Release();
                        }
                    }, token));
                }
                        
                await Task.WhenAll(tasks);
                mainStore.WriteIfChanged();
                deleteQueue.Complete();
                await deleteTask;
            }
            catch (OperationCanceledException) { }

            string result = (token.IsCancellationRequested ? cancelMsg : endMsg) + $"Certificates found: {importStats.all}. Was imported: {importStats.imported}." + (importStats.parsingFailed > 0 ? $" Unrecognized files: {importStats.parsingFailed}" : "");
            LogsHelper.WriteEventLog(result);

            return new ImportSigningCertsResult(result, token.IsCancellationRequested);
        }
    }
    finally
    {
        _cts = null;
    }
}

private bool UploadSigningCerts(Store store, string path, ImportStats importStats)
{
    bool toBeDeleted = true;
    CryptoClient client = CryptoServiceContext.DefaultInstance.CryptoClient;

    try
    {
        CertInfo[] certs = client.GetSignCmsInfo(File.ReadAllBytes(path)).Certs.ToArray(); // здесь непонятно, что такое за коллекция Certs и зачем ее клонировать

        Interlocked.Add(ref importStats.all, certs.Length);

        for (int i = 0; i < certs.Length; i++)
        {

        }
        return toBeDeleted;
    }
    catch (Exception e)
    {
        LogsHelper.WriteLog("SignatureImportService/UploadSigningCerts", e);
        LogsHelper.WriteEventLog($"Ошибка импорта сертификата из подписи: {Path.GetFileName(path)};");
        Interlocked.Increment(ref importStats.errors);
        return false;
    }
}

private async Task DeleteWorkerAsync(ChannelReader<string> reader, CancellationToken token)
{
    await foreach (string path in reader.ReadAllAsync(token))
    {
        try
        {
            File.Delete(path); // если файловая система медленная, здесь можно await Task.Run(() => File.Delete(path));
        }
        catch (Exception e)
        {
            LogsHelper.WriteLog("ImportResult/DeleteSignatures", e);
        }
    }
}

bool переменные тоже бессмысленные, у вас есть потокобезопасный CTS, его и используйте, например так

public bool WasCancelled => _cts?.IsCancellationRequested ?? false;
public bool IsWorking => !_cts?.IsCancellationRequested ?? false;

private CancellationTokenSource _cts;

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

Вот еще почитайте в тему: c# как ускорить добавление потоков используя async-await