我可以使用全局 dict 并行化这个小的 Python 脚本吗？

Question

我在使用 Python3 的 MBA 中遇到这个问题大约需要 2.8 秒。 由于在其核心我们有一个缓存字典，我认为哪个调用首先命中缓存并不重要，因此也许我可以从线程中获得一些收益。 不过我也不太清楚。 这比我通常提出的问题要高一些，但是有人可以引导我完成这个问题的并行化过程吗？

import time
import threading

even = lambda n: n%2==0
next_collatz = lambda n: n//2 if even(n) else 3*n+1

cache = {1: 1}
def collatz_chain_length(n):
    if n not in cache: cache[n] = 1 + collatz_chain_length(next_collatz(n))
    return cache[n]

if __name__ == '__main__':
    valid = range(1, 1000000)
    for n in valid:
        # t = threading.Thread(target=collatz_chain_length, args=[n] )
        # t.start()
        collatz_chain_length(n)

    print( max(valid, key=cache.get) )

或者，如果它是一个糟糕的候选人，为什么？

Answer 1

如果您的工作负载是 CPU 密集型的，那么您将不会从 Python 中的线程中获得很好的提升。 这是因为由于 GIL（全局解释器锁），一次实际上只有一个线程在使用处理器。

但是，如果您的工作负载受 I/O 限制（例如，等待来自网络请求的响应），线程会给您带来一些提升，因为如果您的线程被阻塞等待网络响应，另一个线程可以做有用的工作.

正如 HDN 所提到的，使用多处理会有所帮助 - 这使用多个 Python 解释器来完成工作。

我的方法是将迭代次数除以您计划创建的进程数。 例如，如果您创建 4 个进程， 1000000/4每个进程1000000/4的工作切片。

最后，您需要汇总每个过程的结果并应用max()来获得结果。

Answer 2

线程不会给你带来太多的性能提升，因为它不会绕过全局解释器锁，它在任何给定时刻只会运行一个线程。 由于上下文切换，它实际上甚至可能会减慢您的速度。

如果您想在 Python 中利用并行化实现性能目的，您将不得不使用多处理来实际一次利用多个核心。

Answer 3

我设法在单核16.5x您的代码加速了16.5x倍，请进一步阅读。

如前所述，由于Global Interpreter Lock ，多线程对纯 Python 没有任何改进。

关于多处理 - 有两个选项 1) 实现共享字典并直接从不同进程读取/写入它。 2）将值的范围分成几部分并解决不同过程中单独子范围的任务，然后从所有过程答案中获取最大值。

第一个选项会很慢，因为在您的代码中读取/写入字典是主要的耗时操作，使用进程间共享字典会使其减慢 5 倍，而多核没有任何改进。

第二个选项会带来一些改进，但也不是很好，因为不同的过程会多次重新计算相同的值。 仅当您拥有非常多的内核或在集群中使用许多单独的机器时，此选项才会提供相当大的改进。

我决定采用另一种方法来改进您的任务（选项 3） - 使用Numba并进行其他优化。 我的解决方案也适用于选项 2（子范围的并行化）。

Numba 是即时编译器和优化器，它将纯 Python 代码转换为优化的 C++，然后编译为机器代码。 Numba 通常可以提供 10 到 100 倍的加速。

要使用 numba 运行代码，您只需要安装pip install numba （目前 Python 版本 <= 3.8 支持 Numba，也将很快支持 3.9！）。

我所做的所有改进都在单核上提供了16.5x倍的加速（例如，如果在您的算法上，某些范围内为 64 秒，那么在我的代码上为 4 秒）。

我不得不重写您的代码，算法和想法与您的相同，但我使算法成为非递归的（因为 Numba 不能很好地处理递归）并且还使用列表而不是字典来处理不太大的值。

我的基于 numba 的单核版本有时可能会使用太多内存，这只是因为cs参数控制使用列表而不是字典的阈值，目前这个cs设置为stop * 10 （在代码中搜索），如果您没有太多内存，只需将其设置为例如stop * 2 （但不少于stop * 1 ）。 我有 16GB 的内存，即使上限为 64000000，程序也能正常运行。

另外除了Numba代码我实现了C++解决方案，它的速度似乎和Numba一样，这意味着Numba做得很好！ C++ 代码位于 Python 代码之后。

我对你的算法（ solve_py() ）和我的（ solve_nm() ）进行了时间测量并比较了它们。 时间在代码之后列出。

仅供参考，我也使用我的 numba 解决方案做了多核处理版本，但它没有比单核版本有任何改进，甚至速度变慢。 这一切都是因为多核版本多次计算相同的值。 也许多机版会有明显的改进，但多核可能不会。

由于免费在线服务器上的内存有限，下面的在线试用链接只允许运行小范围！

在线试试吧！

import time, threading, time, numba

def solve_py(start, stop):
    even = lambda n: n%2==0
    next_collatz = lambda n: n//2 if even(n) else 3*n+1

    cache = {1: 1}
    def collatz_chain_length(n):
        if n not in cache: cache[n] = 1 + collatz_chain_length(next_collatz(n))
        return cache[n]

    for n in range(start, stop):
        collatz_chain_length(n)

    r = max(range(start, stop), key = cache.get)
    return r, cache[r]

@numba.njit(cache = True, locals = {'n': numba.int64, 'l': numba.int64, 'zero': numba.int64})
def solve_nm(start, stop):
    zero, l, cs = 0, 0, stop * 10
    ns = [zero] * 10000
    cache_lo = [zero] * cs
    cache_lo[1] = 1
    cache_hi = {zero: zero}
    for n in range(start, stop):
        if cache_lo[n] != 0:
            continue
        nsc = 0
        while True:
            if n < cs:
                cg = cache_lo[n]
            else:
                cg = cache_hi.get(n, zero)
            if cg != 0:
                l = 1 + cg
                break
            ns[nsc] = n
            nsc += 1
            n = (n >> 1) if (n & 1) == 0 else 3 * n + 1
        for i in range(nsc - 1, -1, -1):
            if ns[i] < cs:
                cache_lo[ns[i]] = l
            else:
                cache_hi[ns[i]] = l
            l += 1
    maxn, maxl = 0, 0
    for k in range(start, stop):
        v = cache_lo[k]
        if v > maxl:
            maxn, maxl = k, v
    return maxn, maxl

if __name__ == '__main__':
    solve_nm(1, 100000) # heat-up, precompile numba
    for stop in [1000000, 2000000, 4000000, 8000000, 16000000, 32000000, 64000000]:
        tr, resr = None, None
        for is_nm in [False, True]:
            if stop > 16000000 and not is_nm:
                continue
            tb = time.time()
            res = (solve_nm if is_nm else solve_py)(1, stop)
            te = time.time()
            print(('py', 'nm')[is_nm], 'limit', stop, 'time', round(te - tb, 2), 'secs', end = '')
            if not is_nm:
                resr, tr = res, te - tb
                print(', n', res[0], 'len', res[1])
            else:
                if tr is not None:
                    print(', boost', round(tr / (te - tb), 2))
                    assert resr == res, (resr, res)
                else:
                    print(', n', res[0], 'len', res[1])

输出：

py limit 1000000 time 3.34 secs, n 837799 len 525
nm limit 1000000 time 0.19 secs, boost 17.27
py limit 2000000 time 6.72 secs, n 1723519 len 557
nm limit 2000000 time 0.4 secs, boost 16.76
py limit 4000000 time 13.47 secs, n 3732423 len 597
nm limit 4000000 time 0.83 secs, boost 16.29
py limit 8000000 time 27.32 secs, n 6649279 len 665
nm limit 8000000 time 1.68 secs, boost 16.27
py limit 16000000 time 55.42 secs, n 15733191 len 705
nm limit 16000000 time 3.48 secs, boost 15.93
nm limit 32000000 time 7.38 secs, n 31466382 len 706
nm limit 64000000 time 16.83 secs, n 63728127 len 950

---

与 Numba 相同算法的 C++ 版本位于下面：

在线试试吧！

#include <cstdint>
#include <vector>
#include <unordered_map>
#include <tuple>
#include <iostream>
#include <stdexcept>
#include <chrono>

typedef int64_t i64;

static std::tuple<i64, i64> Solve(i64 start, i64 stop) {
    i64 cs = stop * 10, n = 0, l = 0, nsc = 0;
    std::vector<i64> cache_lo(cs), ns(10000);
    cache_lo[1] = 1;
    std::unordered_map<i64, i64> cache_hi;
    for (i64 i = start; i < stop; ++i) {
        if (cache_lo[i] != 0)
            continue;
        n = i;
        nsc = 0;
        while (true) {
            i64 cg = 0;
            if (n < cs)
                cg = cache_lo[n];
            else {
                auto it = cache_hi.find(n);
                if (it != cache_hi.end())
                    cg = it->second;
            }
            if (cg != 0) {
                l = 1 + cg;
                break;
            }
            ns.at(nsc) = n;
            ++nsc;
            n = (n & 1) ? 3 * n + 1 : (n >> 1);
        }
        for (i64 i = nsc - 1; i >= 0; --i) {
            i64 n = ns[i];
            if (n < cs)
                cache_lo[n] = l;
            else
                cache_hi[n] = l;
            ++l;
        }
    }
    i64 maxn = 0, maxl = 0;
    for (size_t i = start; i < stop; ++i)
        if (cache_lo[i] > maxl) {
            maxn = i;
            maxl = cache_lo[i];
        }
    return std::make_tuple(maxn, maxl);
}

int main() {
    try {
        for (auto stop: std::vector<i64>({1000000, 2000000, 4000000, 8000000, 16000000, 32000000, 64000000})) {
            auto tb = std::chrono::system_clock::now();
            auto r = Solve(1, stop);
            auto te = std::chrono::system_clock::now();
            std::cout << "cpp limit " << stop
                << " time " << double(std::chrono::duration_cast<std::chrono::milliseconds>(te - tb).count()) / 1000.0 << " secs"
                << ", n " << std::get<0>(r) << " len " << std::get<1>(r) << std::endl;
        }
        return 0;
    } catch (std::exception const & ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return -1;
    }
}

输出：

cpp limit 1000000 time 0.17 secs, n 837799 len 525
cpp limit 2000000 time 0.357 secs, n 1723519 len 557
cpp limit 4000000 time 0.757 secs, n 3732423 len 597
cpp limit 8000000 time 1.571 secs, n 6649279 len 665
cpp limit 16000000 time 3.275 secs, n 15733191 len 705
cpp limit 32000000 time 7.112 secs, n 31466382 len 706
cpp limit 64000000 time 17.165 secs, n 63728127 len 950