Python中单线程、多线程和多进程的效率对比实验

GIL机制导致如下结果：

Python的多线程程序并不能利用多核CPU的优势 （比如一个使用了多个线程的计算密集型程序只会在一个单CPU上面运行）
python多线程适合io操作密集型的任务（如socket server 网络并发这一类的）；
python多线程不适合cpu密集操作型的任务，主要使用cpu来计算，如大量的数学计算。
那么如果有cpu密集型的任务怎么办，可以通过多进程来操作（不是多线程）。
假如CPU有8核，每核CPU都可以用1个进程，每个进程可以用1个线程来进行计算。

　1、线性模式测试

import requests
import time
from threading import Thread
from multiprocessing import Process

#定义CPU密集的计算函数
def count(x, y):
    # 使程序完成150万计算
    c = 0
    while c < 500000:
        c += 1
        x += x
        y += y

#定义IO密集的文件读写函数
def write():
    f = open("test.txt", "w")
    for x in range(5000000):
        f.write("testwrite
")
    f.close()

def read():
    f = open("test.txt", "r")
    lines = f.readlines()
    f.close()

def io():
    write()
    read()

#定义网络请求函数
_head = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
    try:
        webPage = requests.get(url, headers=_head)
        html = webPage.text
        return {"context": html}
    except Exception as e:
        return {"error": e}

#---------------------------------------
#CPU密集操作
t = time.time()
for x in range(10):
    count(1, 1)
print("Line cpu", time.time() - t)

# IO密集操作
t = time.time()
for x in range(10):
    io()
print("Line IO", time.time() - t)

# 网络请求密集型操作
t = time.time()
for x in range(10):
    http_request()
print("Line Http Request", time.time() - t)

 --运行---------------------结果：
 ('Line cpu', 97.26900005340576)
 ('Line IO', 24.319000005722046)
 ('Line Http Request', 209.94899988174438)

2、线程模式测试

#定于线程公共函数
def mythread(fun,*args):
    counts = []
    for x in range(10):
        thread = Thread(target=fun, args=args)
        counts.append(thread)
        thread.start()
    e = counts.__len__()
    while True:
        for th in counts:
            if not th.is_alive():
                e -= 1
        if e <= 0:
            break

#测试多线程并发执行CPU密集操作所需时间
t = time.time()
mythread(count,1,1)
print("thread cpu ",time.time() - t)

#测试多线程并发执行IO密集操作所需时间
t = time.time()
mythread(io)
print("thread IO ",time.time() - t)

#测试多线程并发执行网络密集操作所需时间
t = time.time()
mythread(http_request)
print("Thread Http Request", time.time() - t)

--运行---------------------结果：

('thread cpu ', 102.20300006866455)
('thread IO ', 654.5730001926422)
('Thread Http Request', 21.170999765396118)

 3.进程模式测试

def myprocess(fun,*args):
    counts = []
    for x in range(10):
        process = Process(target=fun,args=args)
        counts.append(process)
        process.start()
    e = counts.__len__()
    while True:
        for th in counts:
            if not th.is_alive():
                e -= 1
        if e <= 0:
            break

if __name__ == '__main__': #没这句会报错。
    #测试多进程并发执行CPU密集操作所需时间
    t = time.time()
    myprocess(count,1,1)
    print("Multiprocess cpu", time.time() - t)

    #测试多进程并发执行IO密集型操作
    t = time.time()
    myprocess(io)
    print("Multiprocess IO", time.time() - t)

    #测试多进程并发执行Http请求密集型操作
    t = time.time()
    myprocess(http_request)
    print("Multiprocess Http Request", time.time() - t)

--运行---------------------结果：

('Multiprocess cpu', 20.168999910354614)
('Multiprocess IO', 11.82699990272522)
('Multiprocess Http Request', 21.805000066757202)

实验结果

	CPU密集型操作	IO密集型操作	网络请求密集型操作
单线程操作	97	24	310
多线程操作	102	654	21
多进程操作	20	12	22

通过上面的结果，我们可以看到：

• 多线程在IO密集型的操作下似乎也没有很大的优势，在CPU密集型的操作下明显地比单线程线性执行性能更差，但是对于网络请求这种忙等阻塞线程的操作，多线程的优势便非常显著了
• 多进程无论是在CPU密集型还是IO密集型以及网络请求密集型（经常发生线程阻塞的操作）中，都能体现出性能的优势。不过在类似网络请求密集型的操作上，与多线程相差无几，但却更占用CPU等资源，所以对于这种情况下，我们可以选择多线程来执行

一句话总结：cpu和io密集操作使用多进程，网络操作使用多线程