Python:为什么线程函数比非线程慢 [英] Python: Why is threaded function slower than non thread

问题描述

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

Hello I'm trying to calculate the first 10000 prime numbers.

我首先要进行非线程处理，然后将计算结果分为1到5000，将5001分成10000.我希望使用线程可以使计算速度更快，但输出结果如下:

I'm doing this first non threaded and then splitting the calculation in 1 to 5000 and 5001 to 10000. I expected that the use of threads makes it significant faster but the output is like this:

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

实际上没有什么大区别，只是线程功能甚至慢一点.

There is in fact no big difference except that the threaded function is even a bit slower.

怎么了?

这是我的代码:

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")

推荐答案

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

在CPython中，全局解释器锁(即GIL)是一个互斥体，可以防止多个本机线程一次执行Python字节码.锁定是必要的，主要是因为CPython的内存管理不是线程安全的. (但是，由于存在GIL，因此其他功能已经变得越来越依赖于它所执行的保证.)

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython's memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

这意味着:由于这是CPU密集型的，并且python不是线程安全的，因此它不允许您在同一进程中一次运行多个字节码.因此，您的线程彼此交替，切换开销就是您获得额外时间所得到的.

This means: since this is CPU-intensive, and python is not threadsafe, it does not allow you to run multiple bytecodes at once in the same process. So, your threads alternate each other, and the switching overhead is what you get as extra time.

这篇关于Python:为什么线程函数比非线程慢的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！