Coding妙妙屋

软件漫谈：从底层实现到架构设计

0%

Python GIL与并发编程基础

发表于 更新于 分类于 ，

一、Python GIL概述

在Python中很重要的一个概念就是GIL(全局解释器锁)，一个阻碍机器码并行执行的全局锁，这也代表了Python中的多线程实质上都是伪多线程，同一时刻实际只有一个线程在执行，即便使用多线程也无法做到真正的并发。

由于GIL的存在，在多核系统中执行CPU密集型任务时也无法利用多核优势，使用多线程的性能甚至会比单线程更差一些。这个问题业内通用的做法是使用多进程编程，除此之外本文还将介绍Python中协程的使用(某些场景比线程效率更优的任务调度方式)。

二、并发编程

2.1 多进程与多线程

multiprocessing 是官方提供的多进程管理包，通过使用子进程而非线程有效地绕过了全局解释器锁。 因此，multiprocessing 模块允许程序员充分利用给定机器上的多个处理器。

先看一组多线程与多进程执行独立任务时的性能对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# @Time    : 2021/12/26 22:43 
# @Author  : CharlieZhao
# @File    : test_multiprocessing.py
# @Software: PyCharm
# @Note    : This module is used to test performance of multiprocessing

""" To avoid performance deficiency caused by GIL, multiprocessing is a better way to 
perform concurrent tasks than threading. This module is used to test performance between 
multiprocessing and threading.
"""
 
from multiprocessing import Process
from threading import Thread
import time
 
 
def _print_number(info):
    res = 0
    for i in range(100_000_000):
        res = res + i
    print(info + " task over, result = {}".format(res))
 
 
def show_execution_time(start_time, end_time):
    print("The execution time is {} s".format(end_time - start_time))
 
 
def execute_multiprocessing_task():
    """
    log the execution time of multiprocessing task.
    :return: void
    """
    print(" multiprocessing task start ")
    p1 = Process(target=_print_number, args=("Process 1",))
    p2 = Process(target=_print_number, args=("Process 2",))
 
    start = time.time()
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    end = time.time()
 
    show_execution_time(start, end)
    print(" multiprocessing task end ")
 
 
def execute_threading_task():
    print(" threading task start ")
    t1 = Thread(target=_print_number, args=("Thread 1",))
    t2 = Thread(target=_print_number, args=("Thread 2",))
 
    start = time.time()
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    end = time.time()
 
    show_execution_time(start, end)
    print(" threading task end ")
 
 
if __name__ == "__main__":
    execute_multiprocessing_task()
    execute_threading_task()
    pass
 
"""
result:
 
 multiprocessing task start 
Process 2 task over, result = 4999999950000000
Process 1 task over, result = 4999999950000000
The execution time is 10.988635778427124 s
 multiprocessing task end 
 
 threading task start 
Thread 1 task over, result = 4999999950000000
Thread 2 task over, result = 4999999950000000
The execution time is 19.204389572143555 s
 threading task end 
 
可以很直观的看到在执行两个CPU密集型的独立任务时，使用多进程相较于使用多线程效率快了一倍以上。
当然，Python多线程也不是一无是处，在执行IO密集型任务时，单单使用多进程就不太适合了。
使用多进程+多线程的模式可以绕过阻塞线程，同时相较于单进程+多线程一定程度上减少了CPU线程切换的性能损失。
"""

2.2 协程基础应用

协程是一种用户级的轻量级线程，协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。

再对比一下线程和协程：

多线程：多线程的本质是抢占式多任务调度。不管是进程还是线程，每次阻塞、切换都需要陷入系统调用(system call)，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。

协程：协程的本质是协作式多任务调度，需要用户自己来编写调度逻辑。对于CPU来说，协程其实就是单线程，不需要考虑怎么调度、切换上下文，一定程度避免了CPU调度线程切换的性能损失。

但实际用好协程其实是非常困难的，不管是Debug还是由自己手动维护状态转移、调度逻辑都有很大的挑战，在此给出一个协程的使用样例，后续再继续深入讨论。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# @Time    : 2021/12/29 22:41 
# @Author  : CharlieZhao
# @File    : test_asyncio.py 
# @Software: PyCharm

"""async task example"""

import threading
import asyncio
import time


def show_execution_time(start_time, end_time):
    print("The execution time is {} s".format(end_time - start_time))


async def _async_print_number(info):
    res = 0
    for i in range(100_000_000):
        res = res + i
        # 增加一条线程打印语句观测调用过程
        print(info, " res={} in {}".format(res, threading.currentThread()))
        await asyncio.sleep(1)  # 1s sleep 模拟IO等待,在等待时自动切换任务
    print(info + " task over, result = {}".format(res))


def execute_async_task():
    loop = asyncio.get_event_loop()
    # 创建两个任务
    tasks = [_async_print_number("async task 1:"), _async_print_number("async task 2:")]
    print(" async task start ")

    start = time.time()
    loop.run_until_complete(asyncio.wait(tasks))
    end = time.time()

    show_execution_time(start, end)
    print(" async task end ")


if __name__ == "__main__":
    execute_async_task()

"""
result: 可以看到两个任务1s为周期交替执行(实质是一个任务进入IO阻塞后，通过我们的协程调度逻辑，
在Event_loop中切换至另一个可用任务),且两个任务都在主线程中执行没有线程的切换。
async task start 
async task 2:  res=0 in <_MainThread(MainThread, started 21168)>
async task 1:  res=0 in <_MainThread(MainThread, started 21168)>
async task 2:  res=1 in <_MainThread(MainThread, started 21168)>
async task 1:  res=1 in <_MainThread(MainThread, started 21168)>
async task 2:  res=3 in <_MainThread(MainThread, started 21168)>
async task 1:  res=3 in <_MainThread(MainThread, started 21168)>
async task 2:  res=6 in <_MainThread(MainThread, started 21168)>
async task 1:  res=6 in <_MainThread(MainThread, started 21168)>
async task 2:  res=10 in <_MainThread(MainThread, started 21168)>
async task 1:  res=10 in <_MainThread(MainThread, started 21168)>
async task 2:  res=15 in <_MainThread(MainThread, started 21168)>
async task 1:  res=15 in <_MainThread(MainThread, started 21168)>
"""

2.3 样例代码

⭐️GitHub: Python GIL与并发编程基础，一键三连！