全部问题

我正在查看一个类的实现collections.UserList，并发现了一些不寻常的语法：

def __init__(self, initlist=None):
        self.data = []
        if initlist is not None:
            # XXX should this accept an arbitrary sequence?
            if type(initlist) == type(self.data):
                self.data[:] = initlist
            elif isinstance(initlist, UserList):
                self.data[:] = initlist.data[:]
            else:
                self.data = list(initlist)

这行是什么意思？ self.data[:] = initlist.data[:] 我猜这是创建列表的浅表副本，但为什么要这样呢？为什么不简单写self.data = initlist.data[:]呢？这样的语法是否会产生一些我不知道的效果？

在 Python 中，有两种方法可以将函数应用于可迭代对象的每个元素：

1. 功能map()：

>>> lst = [1, 2, 3, 4]
>>> list(map(str, lst))
['1', '2', '3', '4']
>>> list(map(lambda a: a + 1, lst))
[2, 3, 4, 5]

2. 列表包含：

>>> lst = [1, 2, 3, 4]
>>> [str(i) for i in lst]
['1', '2', '3', '4']
>>> [i + 1 for i in lst]
[2, 3, 4, 5]

《Python 之禅》中有这样一句话：

应该有一种——最好只有一种——明显的方法来做到这一点。

应该有一种，最好只有一种，明显的方法来做到这一点。

由于有两种方法可以将函数应用于可迭代对象，因此 Python 的创建者有充分的理由引入它们。

问题出现了：哪些？在上面的示例中，这两种方法看起来都很自然。显然，存在仅使用这些方法中的一种更容易的问题。那么什么时候最好使用map()以及什么时候最好将其包含在列表中呢？

假设我需要创建一个巨大的（大约一百万）随机数列表。但不仅仅是随机数，而且是不等的随机数。问题是：最快的方法是什么？

选项：

1：（添加前检查每个元素）

import random
nums = []
for i in range(10 ** 6):
    while True:
        x = random.random()
        if nums.find() + 1:
            nums.append(x)
            break
        else:
            continue

2：（生成整个列表后检查）

import random
while True:
    for i in range(10 ** 6):
        nums.append(random.random())
    if list(set(nums)) == nums: break
    else: continue

3：（野蛮☺）

import random
nums = []
x = random.random()
for i in range(10 ** 6):
    nums.append(x * i)

也许还有一些使用特殊方法的其他选项，也许来自其他模块，专门为生成不相等的数字而设计。如果有的话请告诉我。

那么哪个选项更好呢？或者有更快的算法吗？

我有 600 万个小文件（平均大小约为 15 字节），我需要读取这些文件，然后使用处理器进行处理。我之前已经实现过这个，Task.Factory并且它在 asp .net core 2.1 上运行没有问题。花了大约20个小时。

我现在已将应用程序移植到 asp.net 6，并且在测试服务器上，我的 Web 应用程序在运行这些文件操作并崩溃后停止响应任何请求。我在日志中看到错误System.OutOfMemoryException。

我相信我的实现方式还很不理想。我想知道任何其他方法来多线程这项工作或您对当前代码的评论。

控制器方法ImportSignatures：

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

方法ImportSigningCerts：

public static async Task<ImportSigningCertsResult> ImportSigningCerts()
{
    LogsHelper.WriteEventLog("Запуск SignatureImportService");
    WasCancelled = false;
    IsWorking = true;
    ResultStr = "";
    totalSignatures = 0;
    processedSignatures = 0;

    var cancelMsg = "Импорт сертификатов был прерван. \n";
    var endMsg = "Импорт сертификатов успешно завершён. \n";
    var toDelete = new List<string>();

    try
    {
        var configuration = SignatureImportConfiguration.FromCfg();

        using (s_tokenSource = new CancellationTokenSource())
        {
            IEnumerable<string> signatures = Directory.EnumerateFiles(configuration.Path, "*.sig");
            totalSignatures = signatures.Count();

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

            int saveIndex = 1;
            const int proccessedForSave = 100000; // Через какое кол-во обработанных подписей произвести промежуточное сохранение хранилища и удаление подписей
            CancellationToken token = s_tokenSource.Token;

            ThreadPool.GetMinThreads(out int minWorkerThreads, out _);
            using SemaphoreSlim semaphore = new(minWorkerThreads);

            foreach (string path in signatures)
            {
                semaphore.Wait();

                if (WasCancelled)
                    break;

                tasks.Add(Task.Factory.StartNew(() =>
                {
                    try
                    {
                        token.ThrowIfCancellationRequested();

                        if (UploadSigningCerts(mainStore, path, importStats))
                        {
                            if (configuration.NeedCleaning)
                            {
                                lock (s_toDeleteListLockObj)
                                    toDelete.Add(path);
                            }
                        }

                        Interlocked.Increment(ref processedSignatures);
                        lock (s_intermediateSaveLockObj)
                        {
                            if (processedSignatures > proccessedForSave * saveIndex)
                            {
                                LogsHelper.WriteEventLog("Промежуточное сохранение хранилища сертификатов...");

                                mainStore.WriteIfChanged();
                                StartRemovingSignatures(toDelete);
                                saveIndex++;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        if (e is not OperationCanceledException)
                            LogsHelper.WriteLog("SignatureImportService/ImportSigningCerts:Task.Factory.StartNew", e);
                    }
                    finally
                    {
                        semaphore.Release();
                    }
                }, token));
            }

            try
            {
                await Task.WhenAll(tasks);
            }
            catch (OperationCanceledException) { }

            mainStore.WriteIfChanged();
            StartRemovingSignatures(toDelete);
            ResultStr = (WasCancelled ? cancelMsg : endMsg) + $"Certificates found: {importStats.all}. Was imported: {importStats.imported}." + (importStats.parsingFailed > 0 ? $" Unrecognized files: {importStats.parsingFailed}" : "");
        }

        LogsHelper.WriteEventLog(ResultStr);
        return s_tokenSource == null ? new ImportSigningCertsResult(ResultStr) : new ImportSigningCertsResult(ResultStr, WasCancelled);
    }
    finally
    {
        IsWorking = false;
    }
}

方法UploadSigningCerts：

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

    try
    {
        List<CertInfo> certs = client.GetSignCmsInfo(File.ReadAllBytes(path)).Certs.ToList();

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

        for (int i = 0; i < certs.Count; i++)
        {
            lock (s_importLockObj)
            {
                // Код по валидации каждого сертификата из файла, принятие решения об импорте, импорт в хранилище...
            }
        }
        return toBeDeleted;
    }
    catch (Exception e)
    {
        LogsHelper.WriteLog("SignatureImportService/UploadSigningCerts", e);
        LogsHelper.WriteEventLog($"Ошибка импорта сертификата из подписи: {Path.GetFileName(path)};");
        Interlocked.Increment(ref importStats.errors);
        return false;
    }
}

方法StartRemovingSignatures：

private static void StartRemovingSignatures(List<string> toDelete)
{
    if (toDelete.Count > 0)
    {
        List<string> tempToDelete;
        lock (s_toDeleteListLockObj)
        {
            tempToDelete = new List<string>(toDelete);
            toDelete.Clear();
        }

        LogsHelper.WriteEventLog("Удаление успешно обработанных файлов подписей...");

        Task.Factory.StartNew(() =>
        {
            tempToDelete.ForEach(path =>
            {
                try
                {
                    File.Delete(path);
                }
                catch (Exception e)
                {
                    LogsHelper.WriteLog("ImportResult/DeleteSignatures", e);
                }
            });
        });
    }
}

错误文本：

20.08.2023 11:58:01 api/Settings/ImportSignatures
Exception of type 'System.OutOfMemoryException' was thrown.
   at System.Threading.Tasks.Task.EnsureContingentPropertiesInitializedUnsafe()
   at System.Threading.Tasks.Task.AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
   at System.Threading.Tasks.Task.TaskConstructorCore(Delegate action, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
   at Store.Services.SignatureImportService.<>c__DisplayClass20_0.<ImportSigningCerts>b__0(String path)
   at System.Collections.Generic.List`1.ForEach(Action`1 action)
   at Store.Services.SignatureImportService.ImportSigningCerts()
   at Store.Controllers.SettingsController.ImportSignatures()

更新：代码已被编辑

是否有可能以某种方式跟踪 Visual Studio 2022 中垃圾收集器的工作（即一般来说，它发布的所有工作，它以什么顺序执行等）