Python 多线程（一）

Python多线程（一）

目录

• Python多线程（一）
  • 线程
    • Python线程模型
    • Python虚拟机按照下面所述方式来切换线程
  • Threading模块
    • 未引进线程
      • 结果
    • 引入线程
    • 方式一：创建Thread实例，传给它一个函数
      • 结果
      • 解释
    • 方式二：继承Thread，并重新定义run方法
      • 结果
    • 全局解释器锁GIL

线程

​ 一个进程中的各个线程与主线程共享同一片数据空间，因此相对于进程，线程间的信息共享与通讯更加便捷。线程以并发方式执行，得益于这种并行与数据共享的机制，使得多任务协作的实现更加简单。

Python线程模型

​ Python代码的执行是由Python虚拟机控制。在 CPython 中，由于存在 全局解释器锁（GIL），同一时刻只有一个线程可以执行。这种限制使得python的多线程这像在单CPU上跑多进程，只能做到并发，无法做到并行。 。

Python虚拟机按照下面所述方式来切换线程

切换线程被放在一个互斥锁中

1. 设置GIL

2. 执行某个线程A

3. 执行下面操作之一

   1. 执行一定数量的A的python代码（字节码指令）
   2. 线程主动让出控制权

4. 将A的执行状态保存，以备下次执行

5. 解锁GIL

​ 某些 Python I/O 例程(调用了内置的操作系统 C 代码的那种),GIL 会在 I/O 调用前被释放,以允许其他线程在 I/O 执行的时候运行。而对于那些没有太多 I/O 操作的代码而言,更倾向于在该线程整个时间片内始终占有处理器(和 GIL)。总而言之,I/O 密集型的 Python 程序要比计算密集型的代码能够更好地利用多线程环境。

​ 如果想利用多核心计算机的计算资源，推荐使用 multiprocessing 或 concurrent.futures.ProcessPoolExecutor。

Threading模块

未引进线程

def func(name, t):
    print(name, "开始", int(time()))
    sleep(t)
    print(name, "结束", int(time()))

print("程序开始执行")
start = time()
func("猪", 4)
func("牛", 4)
end = time()
print("总共运行:",int( end - start))

结果

程序开始执行
猪 开始 1618821733
猪 结束 1618821737
牛 开始 1618821737
牛 结束 1618821741
总共运行: 8

引入线程

方式一：创建Thread实例，传给它一个函数

• 通过给Thread类构造函数的关键字参数func来定义这个线程将要运行哪个函数，通过args参数来传递func的参数。注意args是一个元组，如果func只需要一个参数时应该这样传参args=（arg1，）。关键字only参数通过kwargs来传入。kwargs是一个字典。

from threading import Thread
from time import sleep, time

def func(name, t):
    print(name, "开始", int(time()))
    sleep(t)
    print(name, "结束", int(time()))

T1 = Thread(target=func,args=('猪',4))
T2 = Thread(target=func,args=('牛',4))

print("主线程开始执行")
start = time()
T1.start()			#线程开始执行
T2.start()			#线程开始执行
end = time()
print("主线程共运行:",int( end - start))

结果

主线程开始执行
猪 开始 1618822143
牛 开始 1618822143
主线程共运行: 0
猪 结束 1618822147
牛 结束 1618822147

解释

当调用thread实例T的start()方法时，这时会创建一个独立的线程，在这个线程中运行实例T的run()方法.run()方法默认将args和kwargs传入target.具体来说就是将 ( '猪' , 4) 传入 func.

当T1.start() T2.start() 调用时，会分别创建两个独立的线程，加上主线程一共有三个独立线程在python虚拟机中运行。三个独立线程以不可预测的进度运行。因此有了上面的运行结果。

注意到，当主线程结束后，整个程序并没有结束。python解释器等到所有的非守护线程结束之后才结束整个程序。这是threading类带来的福利。这也是我们使用threading模块，而不使用更底层的thread模块（这里说的不是Thread类。）的一个原因。

方式二：继承Thread，并重新定义run方法

刚才解释过，调用实例T的start()方法时，会在一个独立的线程中运行实例的run() 方法。run的默认行为是，用构造函数中的target和kwargs来运行target。因此我们可以在子类中重新定义了run方法，在run方法中写出我们想要并发执行的功能。

如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(Thread.init())。!!!!!

from threading import Thread
from time import sleep, time

def func(name, t):
    print(name, "开始", int(time()))
    sleep(t)
    print(name, "结束", int(time()))

class MyThread(Thread):
    def __init__(self,target,args=(), kwargs={}):
        Thread.__init__(self)
        #如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(Thread.__init__())。
        self.target = target
        self.args = args
        self.kwargs = kwargs

    def run(self):
        self.target(*self.args,**(self.kwargs))

print("程序开始执行")
start = time()

T1 = MyThread(func,('猪',4))
T2 = MyThread(func,('牛',4))
T1.start()
T2.start()

end = time()
print("总共运行:",int( end - start))

结果

程序开始执行
猪 开始 1618824594
牛 开始 1618824594
总共运行: 0
猪 结束 1618824598
牛 结束 1618824598

全局解释器锁GIL

CPython 解释器所采用的一种机制，它确保同一时刻只有一个线程在执行 Python bytecode。此机制通过设置对象模型（包括 dict 等重要内置类型）针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得解释器多线程运行更方便，其代价则是牺牲了在多处理器上的并行性。

不过，某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如压缩或哈希时释放 GIL。此外，在执行 I/O 操作时也总是会释放 GIL。

创建一个（以更精细粒度来锁定共享数据的）“自由线程”解释器的努力从未获得成功，因为这会牺牲在普通单处理器情况下的性能。据信克服这种性能问题的措施将导致实现变得更复杂，从而更难以维护