扫描注册表。递归和线程。C＃

关于您的代码：

• 它不起作用，因为没有正常的异常处理。当然，你把它卡在一个地方try catch，但这还不够。仔细阅读文档。
• RegistryKey.OpenSubKey这是一个 api 调用的包装器，它相应地分配了一些 OS 对象。而这个对象在使用后需要释放。因此，类型RegistryKey为 IDisposable。您不仅不免费RegistryKey，而且还OpenSubKey两次调用合同。
• 静态变量当然是一种方便的机制，但他们并没有想出它来模拟全局变量。如果您已经按照为您组织的方式创建静态方法，则将数据作为参数传递。否则，你会得到很大的悲伤，在最初的知识水平上很难捕捉到。此外，您的计数器不受任何方式的并行访问保护（阅读有关 Interlocked 和 Volatile 的信息）
• 您使用的是任务，而不是线程。这些东西之间有很大的区别。因此，您有 130,000 个任务而不是 130,000 个线程。如果你有 130,000 个线程，那么很可能一切都崩溃了（嗯，至少在 32 位进程中）
• 在您的情况下，您不需要创建如此大量的任务，这只会导致过度分配对象。你有足够的沿着溪流的每个分支（见我在下面的例子中是怎么做的）

工作代码示例：

阅读课：

class RegData
{
    public Dictionary<string, StringDictionary> HKCRKeys;
    public Dictionary<string, StringDictionary> HKCUKeys;
    public Dictionary<string, StringDictionary> HKLMKeys;

    public RegData()
    {
        HKLMKeys = new Dictionary<string, StringDictionary>();
        HKCRKeys = new Dictionary<string, StringDictionary>();
        HKCUKeys = new Dictionary<string, StringDictionary>();
    }

    public void ReadSingleThread()
    {
        Clear();
        var FPK = Properties.Settings.Default.RFilterPathList.Cast<string>().ToList();

        //GetRegistry(HKCRKeys, Registry.ClassesRoot, FPK);
        GetRegistry(HKCUKeys, Registry.CurrentUser, FPK);
        GetRegistry(HKLMKeys, Registry.LocalMachine, FPK);
    }

    public void ReadMultiThread()
    {
        Clear();
        var FPK = Properties.Settings.Default.RFilterPathList.Cast<string>().ToList();

        //var hkcrThread = RunThread(HKCRKeys, Registry.ClassesRoot, FPK);
        var hkcuThread = RunThread(HKCUKeys, Registry.CurrentUser, FPK);
        var hklmThread = RunThread(HKLMKeys, Registry.LocalMachine, FPK);

        //hkcrThread.Join();
        hkcuThread.Join();
        hklmThread.Join();
    }

    private void Clear()
    {
        HKLMKeys.Clear();
        HKCRKeys.Clear();
        HKCUKeys.Clear();
    }

    private Thread RunThread(Dictionary<string, StringDictionary> keys, RegistryKey parentKey, List<string> FPK)
    {
        var thread = new Thread(() => {
            try {
                GetRegistry(keys, parentKey, FPK);
            }
            catch (Exception e) {
                Console.WriteLine($"Thread proc for {parentKey.Name} fault: {e.Message}");
            }
        });

        thread.Start();
        return thread;
    }

    //###########
    //
    // Static
    //
    //###########

    static private void GetRegistry(Dictionary<string, StringDictionary> keys, RegistryKey parentKey, List<string> FPK)
    {
        string Name = parentKey.Name;
        if (Properties.Settings.Default.RFilterPathList.Contains(Name) || FPK.Any(t => Name.Contains(t))) {
            return;
        }

        AddValues(keys, parentKey);
        AddSubKeys(keys, parentKey, FPK);
    }

    static private void AddValues(Dictionary<string, StringDictionary> keys, RegistryKey parentKey)
    {
        string[] valueNames = null;
        if (!TryGetValueNames(parentKey, out valueNames)) {
            keys.Add(parentKey.Name, null);
            return;
        }

        var values = new StringDictionary();
        keys.Add(parentKey.Name, values);
        foreach (string name in valueNames) {
            values.Add(name, parentKey.GetValue(name, "error value").ToString());
        }
    }

    static private void AddSubKeys(Dictionary<string, StringDictionary> keys, RegistryKey parentKey, List<string> FPK)
    {
        string[] subKeyNames = null;
        if (!TryGetSubKeyNames(parentKey, out subKeyNames)) {
            return;
        }

        foreach (string subKeyName in subKeyNames) {
            RegistryKey subkey = null;
            if (TryOpenSubKey(parentKey, subKeyName, out subkey)) {
                using (subkey) {
                    GetRegistry(keys, subkey, FPK);
                }
            }
        }
    }

    static private bool TryGetValueNames(RegistryKey parentKey, out string[] valueNames)
    {
        valueNames = null;

        try {
            if (parentKey.ValueCount != 0) {
                valueNames = parentKey.GetValueNames();
            }
        }
        catch (Exception e) {
            Console.WriteLine($"GetValueNames of {parentKey.Name} fail: {e.Message}");
        }

        return valueNames != null;
    }

    static private bool TryGetSubKeyNames(RegistryKey parentKey, out string[] subKeyNames)
    {
        subKeyNames = null;

        try {
            if (parentKey.SubKeyCount != 0) {
                subKeyNames = parentKey.GetSubKeyNames();
            }
        }
        catch (Exception e) {
            Console.WriteLine($"GetSubKeyNames of {parentKey.Name} fail: {e.Message}");
        }

        return subKeyNames != null;
    }

    static private bool TryOpenSubKey(RegistryKey parentKey, string subKeyName, out RegistryKey subKey)
    {
        subKey = null;

        try {
            subKey = parentKey.OpenSubKey(subKeyName);
            if (subKey == null) {
                Console.WriteLine($"OpenSubKey({subKeyName}) of {parentKey.Name} generic fail");
            }
        }
        catch (System.Security.SecurityException) {
            // антиспам
        }
        catch (Exception e) {
            Console.WriteLine($"OpenSubKey({subKeyName}) of {parentKey.Name} fail: {e.Message}");
        }

        return subKey != null;
    }
}

使用示例：

static void Main(string[] args)
{
    TestSingleThread();
    TestMultiThread();

    TestSingleThread();
    TestMultiThread();

    TestSingleThread();
    TestMultiThread();

    Console.ReadKey();
}

static void TestSingleThread()
{
    var sw = new Stopwatch();
    sw.Start();

    var t = new RegData();
    t.ReadSingleThread();

    sw.Stop();
    Console.WriteLine($"Singlethread done: {sw.ElapsedMilliseconds}");
}

static void TestMultiThread()
{
    var sw = new Stopwatch();
    sw.Start();

    var t = new RegData();
    t.ReadMultiThread();

    sw.Stop();
    Console.WriteLine($"Multithread done: {sw.ElapsedMilliseconds}");
}

关于速度：

我测试了您的代码和我的代码，它们在速度方面大致相同。平均而言，单线程模式读取我需要 10-20 秒；在多线程模式下，由于我的HKEY_LOCAL_MACHIN分支很大，其余的很小，因此速度并没有增加太多。

总的来说，我没有像你那样达到如此糟糕的指标。我用谷歌搜索了一下，发现了这个和这个。简而言之...

• 操作系统可以缓存对注册表的访问，因此，在访问一定次数后，访问应该会加快。尝试多次运行代码，性能可以大大提高
• 第一个链接说 HKEY_CLASSES_ROOT 分支可能由于名称过长而存在速度问题。到目前为止，我已经在速度方面与我一起测试过它，它与其他的没有什么不同。但是你可能会有不同的结果，尝试爬取排除这个分支。

关于 C++：

加号当然是一种强大的语言，通常它上面的代码会更快。但是您对操作系统功能的调用非常密集，而且很明显，优点不会在速度上产生任何大的差异。此外，复杂的语言和用它写作的优势，那么你已经写了，会花费你更多的时间和精力，而且收益可能会是一分钱。