对核心和线程的多处理功能

Question

我已经写了一个程序，确定一个梅森素数是素数还是不基于卢卡斯-莱默序列。我想使用多线程和/或多线程来减少检查是否为素数所需的时间，因此，我在这里和Youtube上研究了其他文章和教程，但是这些例子通常使用的实现非常不同；不管它们是使用“线程”还是“线程”模块，并且通常只具有一个功能。如何并行我的两个函数，它们需要不同的时间来计算，并且需要返回到第三个函数，最后的结果(请注意，我最近才开始编程)。我知道对算法本身的优化；如果Mersenne素数的最后一个数字是偶数或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())

通过并行代码，我将三个函数简化为一个函数：

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)结果= pool.map(Checker，n3，n4)，(，( 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长的数组中，输出对Prime为True，对于非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)

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

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

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