场景
单进程，两线程，两进程，两协程 数20万的场景对比
单进程：单个进程count 20万
两线程：启动两个线程，对全局变量数20万
两进程：启动两个进程，通过共享内存方式创建Value对象，数20万
两协程：启动两个协程，数20万，需要注意asyncio.sleep(0)主动释放cpu的位置
环境
通过VMware创建的linux虚拟机，centos6.3，2core，4G。
我在windows宿主机上也做了尝试，但跑两进程共享Value时，会异常的慢，数20左右就是秒级的，不清楚原因。其余三个场景windows宿主机上性能会更好。
代码
import threading
import multiprocessing
from multiprocessing import Manager
import asyncio
import time
g_num = 0
lock = threading.Lock()
LOOP = 100000
def single_count():
global g_num
g_num = 0
for i in range(0, LOOP * 2):
g_num += 1
def my_thread():
global g_num
for i in range(0, LOOP):
with lock:
g_num = g_num + 1
def my_process(g_num, process_lock):
for i in range(0, LOOP):
with process_lock:
g_num.value += 1
def main0(i):
st = time.time()
single_count()
print("第%d次计算结果：%d 耗时: %s" % (i, g_num, (time.time() - st)))
def main1(i):
st = time.time()
global g_num
g_num = 0
t1 = threading.Thread(target=my_thread)
t2 = threading.Thread(target=my_thread)
# 启动线程
t1.start()
t2.start()
# 阻塞函数，等待线程结束
t1.join()
t2.join()
print("第%d次计算结果：%d 耗时: %s" % (i, g_num, (time.time() - st)))
def main2(i):
st = time.time()
# 声明进程的共享变量
manager = Manager()
g_num = manager.Value('g_num', 0)
process_lock = multiprocessing.Lock()
t1 = multiprocessing.Process(target=my_process, args=(g_num, process_lock,))
t2 = multiprocessing.Process(target=my_process, args=(g_num, process_lock,))
# 启动进程
t1.start()
t2.start()
# 阻塞函数，等待进程结束
t1.join()
t2.join()
# 获取全局变量的值
print("第%d次计算结果：%d 耗时: %s" % (i, g_num.value, (time.time() - st)))
async def coroutine():
global g_num
# asyncio.sleep主动释放cpu,如果写到for里边就会多次释放cpu，会慢
for i in range(0, LOOP):
g_num = g_num + 1
await asyncio.sleep(0)
async def gather_co():
await asyncio.gather(coroutine(), coroutine(), )
def main3(i):
global g_num
g_num = 0
st = time.time()
# 加这两句的原因https://www.cnblogs.com/SunshineKimi/p/12053914.html
new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(new_loop)
loop = asyncio.get_event_loop()
loop.run_until_complete(gather_co())
loop.close()
print("第%d次计算结果：%d 耗时: %s" % (i, g_num, (time.time() - st)))
if __name__ == "__main__":
print("单个进程数20万")
for i in range(1, 5):
main0(i) # 耗时 0.02，CPU密集型的任务，用单个进程的速度会比多线程更快
print("两个线程数20万")
for i in range(1, 5):
main1(i) # 耗时0.56
print("两个进程共享内存数20万")
for i in range(1, 5):
main2(i) # 耗时42.26
print("两个协程数20万")
for i in range(1, 5):
# 耗时: 0.035 主要看在哪await,如果放到for循环里await，就很慢
main3(i)
linux测试结果
单个进程数20万
第1次计算结果：200000 耗时: 0.02316737174987793
第2次计算结果：200000 耗时: 0.021372079849243164
第3次计算结果：200000 耗时: 0.029618263244628906
第4次计算结果：200000 耗时: 0.03957533836364746
两个线程数20万
第1次计算结果：200000 耗时: 0.5690386295318604
第2次计算结果：200000 耗时: 0.519477128982544
第3次计算结果：200000 耗时: 0.3434329032897949
第4次计算结果：200000 耗时: 0.5677127838134766
两个进程共享内存数20万
第1次计算结果：200000 耗时: 43.1370644569397
第2次计算结果：200000 耗时: 47.416287422180176
第3次计算结果：200000 耗时: 40.489630460739136
第4次计算结果：200000 耗时: 41.213842153549194
两个协程数20万
第1次计算结果：200000 耗时: 0.04945230484008789
第2次计算结果：200000 耗时: 0.06548023223876953
第3次计算结果：200000 耗时: 0.06570887565612793
第4次计算结果：200000 耗时: 0.02965259552001953
