Python高阶-多线程

一、GIL锁

全局解释性锁
让Python同一时刻只有一个线程在CPU上运行字节码
无法将多个线程映射到多个CPU上同时运行

二、线程同步

主要讲锁相关的知识
锁实现了上下文协议即 __enter__ __exit__ 可以用with语句

1、Lock

Python中最基础的锁
一个上锁对应一个释放锁

2、RLock

可重入锁，上几把锁就需要释放几次

3、Condition

条件变量

from threading import Thread, Condition


def speak(cond):
    with cond:
        print("开始讲话")
        cond.notify() # 释放锁，使wait解除堵塞
        cond.wait()
        print("接收到接受者信息")
        cond.notify()
        cond.wait()


def listen(cond):
    with cond: #或者直接cond.acquire(),此时结束的时候要释放锁
        cond.wait() # 释放上面cond的锁，产生一把新的锁，放到一个双向队列中，此时堵塞
        print("开始收听")
        cond.notify()
        cond.wait()
        print("接收到讲话者信息")
        cond.notify()
if __name__ == '__main__':
    cond = Condition()
    t1 = Thread(target=speak, args=(cond,))
    t2 = Thread(target=listen, args=(cond,))
    t2.start()
    t1.start()

4、Semaphore

信号量
可以用来控制同时运行的线程数量

import time
from threading import Semaphore, Thread


def get_html_url(s, t):
    with s:
     # s.acquire() value -1  
     #s.release()  value +1
     # 当value = 0 会堵塞
        print(f"{t}")
        time.sleep(2)


if __name__ == '__main__':
    s = Semaphore(3) # 控制线程数量
    for i in range(20):
        t = Thread(target=get_html_url, args=(s, i))
        t.start()

三、线程池

#主要要去了解源码，submit返回的future对象
import time
from concurrent.futures import ThreadPoolExecutor，as_completed

# as_completed接受iterable ，iterable中是Future对象

def func(*args):
    time.sleep(2)
    print(args)


executor = ThreadPoolExecutor(3) 
#线程池的实例对象中有map方法，map(func,iterable) # iterable为函数的参数
for i in range(10):
    future=executor.submit(func, (1, 2, 3))
    future,done() #线程运行状态
    future.cancel() #取消还未运行的线程
    future.result() #线程运行结果，会堵塞
 # map 和as_completed都是的返回值都是iterable 可以用for循环

本文地址：https://blog.csdn.net/qq_43006401/article/details/110457188