python - 核心和线程的多处理功能

Question

我编写了一个程序，可以根据 Lucas-Lehmer 序列确定梅森素数是否为素数。我想使用多处理和/或多线程来减少检查是否为素数所需的时间，因此我研究了此处和 YouTube 上的其他帖子和教程，但是这些示例通常使用截然不同的实现;无论它们是使用“线程”还是“线程”模块，并且通常只具有一种功能。我如何并行我的两个功能；这需要不同的时间来计算，并且需要将计算返回到第三个函数以获得最终结果。(请注意，我最近才开始编程)。我知道我可以对算法本身进行优化；例如，如果梅森素数的最后一位数字是偶数或 5，那么它应该只打印而不是素数，但我想特别关注并行。谢谢。代码:

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

如果名称 == '主要': 从多处理导入池 以 Pool(4) 作为池: 下午1 = 2 n1 = 4 PM2=3 n2 = (n1 ** 2 - 2) 下午3 = 4 n3 = (n2 ** 2 - 2) pm4=5 n4 = (n3 ** 2 - 2) 结果 = pool.map(Checker, [(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) 结果 = pool.map(Checker, [(pm1, n1), (pm2, n2), (pm3, n3), (pm4, n4)]) 打印(结果)

在 4 长的数组中，对于素数，输出将为 True，对于非素数，输出将为 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)

这将并行运行检查器四次。

编辑:但是，这可能仍然比串行执行慢，除非您要求在每次检查中完成大量计算。

编辑:展示如何保护多处理内容的执行。