Python 3.11.7 进程、线程速度对比

Python 3.11.7 进程、线程速度对比

当前使用版本为 Python 3.11.7

1.进程 处理（无数据保护）

#进程速度
from multiprocessing import Process
import time

n = 0 

def task1():
    global n
    for i in range(100_000_000):
        n += 1
    print("-->task1中的n值是-《{:,}》-".format(n))
def task2():
    global n
    for i in range(100_000_000):
        n += 1
    print("-->task2中的n值是-《{:,}》-".format(n))
if __name__ == "__main__":
    process1 = Process(target=task1, )
    process2 = Process(target=task2, )
    
    t1 = time.time()
    process1.start()
    process2.start()

    
    process1.join()
    process2.join()
    t2 = time.time()
    t3 = t2-t1
    print("最终数字为",n, "时间为", t3,"秒")
    
# 最终数字为 0 时间为 7.642554998397827 秒
# -->task2中的n值是-《100,000,000》-
# -->task1中的n值是-《100,000,000》-

结果为：7.6秒

2.线程 处理

from threading import Thread
import time

n = 0

def task1():
    global n
    for i in range(100_000_000):
        n += 1
    print("-->task1中的n值是-《{:,}》-".format(n))
def task2():
    global n
    for i in range(100_000_000):
        n += 1
    print("-->task2中的n值是-《{:,}》-".format(n))
        
if __name__ == "__main__":
    thread1 = Thread(target=task1, )
    thread2 = Thread(target=task2, )

    t1 = time.time()
    thread1.start()
    thread2.start()

    
    thread1.join()
    thread2.join()
    t2 = time.time()
    t3 = t2-t
    print("最终数字为",n, "时间为", t3,"秒")
    
#-->task1中的n值是-《199,553,915》-
#-->task2中的n值是-《200,000,000》-
#最终数字为 200000000 时间为 14.593790292739868 秒

结果为：14.6秒，

3.单线程 速度

import time
n = 0 

def task1():
    global n
    for i in range(200_000_000):
        n += 1
    print("-->task1中的n值是-《{:,}》-".format(n))

t1 = time.time()
task1()
t2 = time.time()
t3 = t2-t1
print("最终数字为",n, "时间为", t3,"秒")

# -->task1中的n值是-《200,000,000》-
# 最终数字为 200000000 时间为 14.337766170501709 秒

结果为：14.34秒

4.双线程各自跑

from multiprocessing import Process
from threading import Thread
import time

def task1():
    n=0
    for i in range(100_000_000):
        n += 1
    print("-->task1中的n值是-《{:,}》-".format(n))
def task2():
    n=0
    for i in range(100_000_000):
        n += 1
    print("-->task2中的n值是-《{:,}》-".format(n))
        
if __name__ == "__main__":
    thread1 = Thread(target=task1, )
    thread2 = Thread(target=task2, )

    t1 = time.time()
    thread1.start()
    thread2.start()

    
    thread1.join()
    thread2.join()
    t2 = time.time()
    t3 = t2-t1
    print("最终时间为", t3,"秒")

# -->task1中的n值是-《100,000,000》-
# -->task2中的n值是-《100,000,000》-
# 最终时间为 9.990402936935425 秒

结果为：9.99秒

序号	项目	时间（s）
1	进程 处理（无数据保护）	7.6
2	线程 处理	14.6
3	单线程 速度	14.34
4	双线程各自跑	9.99

总结

从表格中，可以看到：
1、双线程同时处理一份数据的时间用时最久，比单线程处理的时间还要长，是两个进程用时的两倍。
2、两个进程处理的速度最快（但是没有进行数据保护）。
3、两个线程的各自处理数据的时候时间比两个进程时间稍慢，低24%。

因此计算密集型的不建议用多线程操作，都资源浪费在切换上了，单线程即可。