【Python进阶】多进程与多线程，全局解释器锁GIL

Runaway_pilot

已于 2022-07-05 15:46:07 修改

阅读量470

点赞数

分类专栏： python知识文章标签： python

于 2022-06-25 16:24:04 首次发布

本文链接：https://blog.csdn.net/Runaway_pilot/article/details/125459913

版权

python知识专栏收录该内容

8 篇文章 0 订阅

订阅专栏

requests

Requests是基于urllib，使用Apache2 Licensed许可证开发的HTTP库。其在python内置模块的基础上进行了高度封装，使得Requests能够轻松完成浏览器相关的任何操作。

Requests能够模拟浏览器的请求，一个模拟请求由以下四个部分组成

url
method
body
headers

更多requests库的使用及方法： https://zhuanlan.zhihu.com/p/393533467

安装requests

pip install requests

模拟请求百度

import requests


def request_baidu():
    url = "https://www.baidu.com/"
    # body = ""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/
        537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36"
    }
    response = requests.get(url=url, headers=headers)
    print(response.text)

这里贴一个大佬的文章内容，写的太好了可以帮助理解

进程是操作系统分配资源的最小单元, 线程是操作系统调度的最小单元。

一个应用程序至少包括1个进程，而1个进程包括1个或多个线程，线程的尺度更小。

每个进程在执行过程中拥有独立的内存单元，而一个线程的多个线程在执行过程中共享内存。

计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。

假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。注: 多核的CPU就像有了多个发电厂，使多工厂(多进程)实现可能。

进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

一个车间里，可以有很多工人。他们协同完成一个任务。

线程就好比车间里的工人。一个进程可以包括多个线程。

车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。

可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。

一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫"互斥锁"（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。

还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。

这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。

不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。

多线程和多进程

什么是进程和线程

进程：可以简单地认为是一个程序，进程是操作系统分配资源的最小单位。

线程：一个进程可以有多个线程，每个线程可以独立完成一些任务。线程是操作系统进行运算调度的最小单位。

使用多线程

from threading import Thread
    
for i in range(10):
    # 只是创建了线程对象
    t = Thread(target=request_baidu)
    # 启动线程
    t.start()

等待任务完成后我们需要回到主进程，通过调用Thread对象的join方法

# 保存当前thread对象
thread_array = []
for i in range(10):
    t = Thread(target=request_baidu, args=(i, ))
    thread_array.append(t)
    t.start()
# 调用thread对象join接口, 等待任务完成后回到主进程
for t in thread_array:
    t.join()
print("done!")

如何拿到返回结果

赋值到全局变量当中, 添加到可变对象之中

result = []
def request_baidu(index):
	...
    result.append(response)
    
if __name__ == "__main__":
    thread_array = []
    for i in range(10):
        t = Thread(target=request_baidu, args=(i, ))
        thread_array.append(t)
        t.start()
    for t in thread_array:
        t.join()
    print("done!")
    print(result)

使用多进程

from multiprocessing import Process   

for i in range(10):
    # 只是创建了进程对象
    p = Process(target=request_baidu)
    # 启动进程
    p.start()

等待任务完成后我们需要回到主进程，通过调用Process 对象的join方法，方法与线程一致

如何拿到返回结果

多进程无法通过全局变量存储返回结果。

多进程相当于启动了多个程序, 共同执行了同一份代码, 他们之间的内存地址完全不一样。

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

result = []
print(f"主进程result内存地址: {id(result)}")

def request_baidu(index):
    time.sleep(2)
    url = "https://www.baidu.com/"
    # body = ""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36"
    }
    response = requests.get(url=url, headers=headers)
    print(f"当前请求序号: {index}, 返回结果状态码: {response.status_code}")
    print(f"子进程result内存地址: {id(result)}")
    result.append(response)

# 如果没有判断入口代码段if __name__ == "__main__", 多进程程序会报错
# 原因是windows和pycharm的进程阻塞带来的问题
if __name__ == "__main__":
    process_array = []
    for i in range(10):
        p = Process(target=request_baidu, args=(i, ))
        process_array.append(p)
        p.start()
    for p in process_array:
        p.join()
    print("done!")
    print(result)

多进程和多线程的异同点

相同点

都是对cpu工作时间段的描述, 只是颗粒度不同.

简单地说就是多进程和多线程都会调用cpu资源的, 但是进程可以启动多个线程去执行.
在linux内核态不区分进程和线程

不同点

进程有自己的独立地址空间, 建立数据表来维护代码段, 堆栈段和数据段, 而线程共享进程中的资源, 使用相同的地址空间, 所以线程间的切换快得多.
因为线程共享进程的全局变量, 静态变量等对象, 线程间的通信更为方便, 而进程间的通信更加复杂, 需要以ipc的方式进行.
多进程要比多线程要健壮. 进程之间一般不会相互影响, 而多线程有一条线程崩溃, 会导致整个进程跟着发生崩溃或者无法正常退出等.

全局解释器锁(GIL)

什么是GIL锁

GIL锁又称全局解释器锁。作用就是限制多线程同时执行，保证同一时间内只有一个线程在执行。线程非独立的，所以同一进程里线程是数据共享，当各个线程访问数据资源时会出现“竞争”状态，即数据可能会同时被多个线程占用，造成数据混乱，这就是线程的不安全。所以引进了互斥锁，确保某段关键代码、共享数据只能由一个线程从头到尾完整地执行。

GIL并不是Python的特性，Python完全可以不依赖于GIL。

在Python语言中多线程其实是假的多线程，它只会在一个CPU上运行。因为在Python上开启多个线程，由于GIL的存在，每个单独线程都会在竞争到GIL后才运行，这样就干预OS内部的进程（线程）调度，结果在多核CPU上：Python的多线程实际是串行执行的，并不会同一时间多个线程分布在多个CPU上运行。