使程序支持多线程

Question

我正在制作一个质数计算器，它运行得很好，但我想通过多线程让它更快。我想知道有没有人能给我推荐一些资源（Python的文档对我帮助不大），或者给我一个在我代码中的例子。

import time
#Set variables
check2 = 0
check3 = 0
check5 = 0
check7 = 0
#get number
primenum = int(input("What number do you want to find out whether it is prime or not?\nIt must be a natural number\n**Calculations may take some time depending of the power of the computer and the size of the number**\n"))
#set divisor
primediv = primenum - 2
#assume it's prime until proven innocent
prime = 1
#Create variable for GUI
working = "Calculating"
work = 10000000
#set the number of divides to 0
divnum = 0
#start the clock
starttime = time.perf_counter()
#until it is not prime or divided by 1...
while prime == 1 and primediv >7:
    #does simple checks to deal with large numbers quickly
    #Does this by dividing with small numbers first
    if primenum != 0 and check2 == 0:
        primemod = primenum % 2
        check2 = 1
        print(working + ".")
        working = working +"."
    elif primenum != 0 and check3 == 0:
        primemod = primenum % 3
        check3 = 1
        print(working + ".")
        working = working +"."
    elif primenum != 0 and check5 == 0:
        primemod = primenum % 5
        check5 = 1
        print(working + ".")
        working = working + "."
    elif primenum != 0 and check7 == 0:
        primemod = primenum % 7
        check7 = 1
        print(working + ".")
        working = working + "."
    #divde and get remainder
    else:
        primemod = primenum % primediv
        #Working visuals
        if divnum == work:
            print(working + ".")
            working = working +"."
            work = work + 10000000
    #if the can't be devided evenly
    if primemod == 0:
        #then it isn't a prime
        prime = 0
    else:
        #if it can, keep going
        primediv = primediv - 2
        divnum = divnum + 1
#print results
if prime == 1:
    print("That number is prime")
    print ("It took ", time.perf_counter()-starttime, " seconds to perform that calculation\n")
else:
    print("That number is not prime")
    print ("It took ", time.perf_counter()-starttime, " seconds to perform that calculation\n")

Answer 1

Python最常用的版本（CPython和PyPy）都有一个叫做全局解释器锁（"GIL"）的东西。这个锁的主要作用是让内存管理变得简单。它的效果就是在同一时间内，只能有一个线程在执行Python的字节码。所以，如果一个程序的所有计算都是用Python来做的，使用多线程并不会让它变得更快。

通常，让程序变快的最好方法是找到更好的算法。比如看看这个：

def prime_list(num):
    """Returns a list of all prime numbers up to and including num.

    :num: highest number to test
    :returns: a list of primes up to num

    """
    if num < 3:
        raise ValueError('this function only accepts arguments > 2')
    candidates = range(3, num+1, 2)  # (1)
    L = [c for c in candidates if all(c % p != 0 for p in range(3, c, 2))]  #(2)
    return [2] + L  # (3)

(1) 大于2的偶数可以被2整除，所以它们不可能是质数，可以不考虑。

(2) 要判断一个奇数c是否是质数，必须确保c除以前面的所有奇数（p）的结果都不为零。

(3) 2也是一个质数。

一个小的改进是，p只需要检查到sqrt(c)为止。

def prime_list2(num):
    if num < 3:
        raise ValueError('this function only accepts arguments > 2')
    candidates = range(3, num+1, 2)
    L = [c for c in candidates if all(c % p != 0 for p in
         range(3, int(math.sqrt(c))+1, 2))]
    return [2] + L

注意，我使用了列表推导式而不是for循环，因为它们通常更快。

最后，像亚当·斯密提到的那种筛法；

def prime_list3(num):
    num += 1
    candidates = range(3, num, 2)
    results = [2]
    while len(candidates):
        t = candidates[0]
        results.append(t)
        candidates = [i for i in candidates if not i in range(t, num, t)]
    return results

要看看哪个更快，我们需要进行测试；

首先测试num=100。

In [8]: %timeit prime_list(100)
1000 loops, best of 3: 185 µs per loop

In [9]:  %timeit prime_list2(100)
10000 loops, best of 3: 156 µs per loop

In [10]: %timeit prime_list3(100)
1000 loops, best of 3: 313 µs per loop

然后是1000：

In [11]: %timeit prime_list(1000)
100 loops, best of 3: 8.67 ms per loop

In [12]: %timeit prime_list2(1000)
1000 loops, best of 3: 1.94 ms per loop

In [13]: %timeit prime_list3(1000)
10 loops, best of 3: 21.6 ms per loop

再然后是10000；

In [14]: %timeit prime_list(10000)
1 loops, best of 3: 680 ms per loop

In [15]: %timeit prime_list2(10000)
10 loops, best of 3: 25.7 ms per loop

In [16]: %timeit prime_list3(10000)
1 loops, best of 3: 1.99 s per loop

在这些算法中，prime_list2似乎表现得最好。