python并发编程--单进程多线程多进程协程性能对比

场景
单进程，两线程，两进程，两协程 数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