内核和线程的多处理函数

Question

我写了一个程序，根据Lucas-Lehmer序列判断Mersenne素数是否为素数。我想使用多处理和/或多线程来减少检查prime所需的时间，因此我研究了这里和Youtube上的其他帖子和教程，但是这些示例通常使用非常不同的实现；不管它们是使用“线程”还是“线程”模块，通常只使用功能单一。如何并行我的两个函数；这两个函数的计算时间不同，需要将计算结果返回到第三个函数才能得到最终结果（请注意，我最近才开始编程）。我知道我可以对算法本身进行优化；例如，如果Mersenne素数的最后一个数字是偶数或5，那么它应该只打印not prime，但我想特别关注并行。谢谢。代码：

import time


def MersennePrime(pm=3):
    mp = (2 ** pm) - 1
    print(pm)
    print(mp)
    while pm <=25:
        pm = pm + 1
        print(mp)


def LucasLehmerSequence(n=4):
    lls = (n ** 2) - 2 # Calculates the 2nd digit of the Lucas-Lehmer Sequence.
    print(n)
    print(lls)
    while pm <= 25:
        n = lls
        lls = (n ** 2) - 2
        print(lls)


def Checker(pm=3, n=4):
    start = time.time()
    mp = (2 ** pm) - 1
    while pm <= 25:
        lls = (n ** 2) - 2
        n = lls # Updates the value of n to be = the previous sequence entry.
        lls = (n ** 2) - 2
        pm = pm + 1 # Adds 1 to the power of the Mersenne.
        mp = (2 ** pm) - 1
        if (lls % mp) == 0: # If nth in sequence has a remainder of 0 when / by the nth Mersenne it is a Mersenne Prime.
            print(str(mp) + ' is prime.')
        else:
            print(str(mp) + ' is not prime')
    end = time.time()
    print(end - start)


print(Checker())

使用并行代码，我将3个函数简化为一个：

def Checker(pm_n=(2, 4)):
pm, n = pm_n
lls = (n ** 2 - 2)
lls = n
lls = (n ** 2 - 2)
mp  = (2 ** pm - 1)
pm = pm + 1
mp  = (2 ** pm - 1)
if (lls % mp == 0):
    return True
else:
    return False

如果名称=='main'： 从多处理导入池 池（4）作为池： pm1=2 n1=4 pm2=3 n2=（n1**2-2） pm3=4 n3=（n2**2-2） pm4=5 n4=（n3**2-2） 结果=池.map（检查者，[（pm1，n1），（pm2，n2），（pm3，n3），（pm4，n4）]） 打印（结果） 如果为真： pm1=pm4+1 n1=（n4**2-2） pm2=pm1+1 n2=（n1**2-2） pm3=pm2+1 n3=（n2**2-2） pm4=pm3+1 n4=（n3**2-2） 结果=池.map（检查者，[（pm1，n1），（pm2，n2），（pm3，n3），（pm4，n4）]） 打印（结果）

在4长的数组中，Prime的输出为True，not Prime的输出为False。接下来的4个数是否为素数将在一个数组中输出。你知道吗

Answer 1

不要使用线程。Python有一个全局解释器锁，所以多线程将比单线程慢。多处理可能会有所帮助，不过最好是并行运行多个Checker。您找到的大多数示例都将使用多处理池。它看起来是这样的：

if __name__ == "__main__":
    from multiprocessing import Pool
    with Pool(4) as pool:
        result = pool.map(Checker, [(pm1, n1), (pm2, n2), (pm3, n3), (pm4, n4)])
        print(result)

这将并行运行检查器四次。你知道吗

编辑：但是，这可能仍然比串行执行慢，除非您要求在每个检查中执行大量计算。你知道吗

编辑：演示如何保护多处理内容的执行。你知道吗