Python：为什么线程函数比非线程慢

Question

您好，我正在尝试计算前 10000 个素数。

我首先在非线程中执行此操作，然后将计算拆分为 1 到 5000 和 5001 到 10000。我预计使用线程可以显着加快速度，但输出是这样的：

    --------Results--------
Non threaded Duration:  0.012244000000000005 seconds
Threaded Duration:  0.012839000000000017 seconds

其实并没有什么大的区别，只是线程函数更慢了一点。

怎么了？

这是我的代码：

import math
from threading import Thread

def nonThreaded():
    primeNtoM(1,10000)


def threaded():
    t1 = Thread(target=primeNtoM, args=(1,5000))
    t2 = Thread(target=primeNtoM, args=(5001,10000))
    t1.start()
    t2.start()
    t1.join()
    t2.join()


def is_prime(n):
    if n % 2 == 0 and n > 2: 
        return False
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        if n % i == 0:
            return False
    return True

def primeNtoM(n,m):
    L = list()
    if (n > m):
        print("n should be smaller than m")
        return
    for i in range(n,m):
        if(is_prime(i)):
                L.append(i)

if __name__ == '__main__':
    import time
    print("--------Nonthreaded calculation--------")
    nTstart_time = time.clock()
    nonThreaded()
    nonThreadedTime = time.clock() - nTstart_time

    print("--------Threaded calculation--------")

    Tstart_time = time.clock()
    threaded()
    threadedTime = time.clock() - Tstart_time

    print("--------Results--------")
    print ("Non threaded Duration: ",nonThreadedTime, "seconds")
    print ("Threaded Duration: ",threadedTime, "seconds")

Answer 1

来自：https://wiki.python.org/moin/GlobalInterpreterLock

在 CPython 中，全局解释器锁或 GIL 是一个互斥锁，可防止多个本机线程同时执行 Python 字节码。这个锁是必要的，主要是因为 CPython 的内存管理不是线程安全的。 （但是，由于 GIL 的存在，其他功能已经发展到依赖于它强制执行的保证。）

这意味着：由于这是 CPU 密集型的，而且 python 不是线程安全的，它不允许您在同一个进程中同时运行多个字节码。因此，您的线程会相互交替，而切换开销就是您获得的额外时间。

Answer 2

您可以使用multiprocessing 模块，其结果如下：

('Non threaded Duration: ', 0.016599999999999997, 'seconds')
('Threaded Duration: ', 0.007172000000000005, 'seconds')

...在对您的代码进行这些更改之后（将“线程”更改为“进程”）：

import math
#from threading import Thread
from multiprocessing import Process

def nonThreaded():
    primeNtoM(1,10000)


def threaded():
    #t1 = Thread(target=primeNtoM, args=(1,5000))
    #t2 = Thread(target=primeNtoM, args=(5001,10000))
    t1 = Process(target=primeNtoM, args=(1,5000))
    t2 = Process(target=primeNtoM, args=(5001,10000))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

通过生成实际的操作系统进程而不是使用进程内线程，您可以消除@Luis Masuelli 的回答中讨论的 GIL 问题。

multiprocessing 是一个支持使用 API 类似于 threading 模块。多处理包 提供本地和远程并发，有效地回避 通过使用子进程而不是线程来全局解释器锁。 因此，多处理模块允许程序员完全 利用给定机器上的多个处理器。它在两个 Unix 上运行 和窗户。