1. 全局解释器锁GIL
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。
在多线程环境中，Python 虚拟机按以下方式执行：
a、设置 GIL；
b、切换到一个线程去运行；
c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；
d、把线程设置为睡眠状态；
e、解锁 GIL；
d、再次重复以上所有步骤。
在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(由于在这期间没有Python的字节码被运行，所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。
2. 线程队列
queue队列 ：使用import queue，用法与进程Queue一样
queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.
- class
queue.Queue(maxsize=0) #先进先出
import queue
#先进先出型
q=queue.Queue(3)
q.put(3)
q.put(2)
q.put(1) print(q.get())
print(q.get())
print(q.get()) """
结果
3
2
1
"""
先进先出型
class queue.LifoQueue(maxsize=0) #last in fisrt out
import queue q=queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3) print(q.get())
print(q.get())
print(q.get())
"""
结果
3
2
1 """
先进后出行
class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
import queue q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素一般是优先级(一般是数字,也可以是非数字),数字越小,优先级越小
q.put((-1,"a"))
q.put((0,"b"))
q.put((10,"c"))
q.put((20,"d")) print(q.get())
print(q.get())
print(q.get())
print(q.get()) """
结果
数字越小,优先级越高,越优先输出
(-1, 'a')
(0, 'b')
(10, 'c')
(20, 'd') """
优先级队列
注:优先级相同的会根据第二元素比较,第二个元素是根据编码的顺序比较,并且第二个元素的类型必须一致并且,是有序的才可以比较
如果两个值的优先级一样，那么按照后面的值的acsii码顺序来排序,如果字符串第一个数元素相同，比较第二个元素的acsii码顺序
TypeError: unorderable types: dict() < dict() 不能是字典
优先级相同的两个数据，他们后面的值必须是相同的数据类型才能比较，可以是元祖，也是通过元素的ascii码顺序来排序
3. Python标准模块--concurrent.futures
#1 介绍
concurrent.futures模块提供了高度封装的异步调用接口
ThreadPoolExecutor：线程池，提供异步调用
ProcessPoolExecutor: 进程池，提供异步调用
Both implement the same interface, which is defined by the abstract Executor class. #2 基本方法
#submit(fn, *args, **kwargs)
异步提交任务 #map(func, *iterables, timeout=None, chunksize=1)
取代for循环submit的操作 #shutdown(wait=True)
相当于进程池的pool.close()+pool.join()操作
wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False，立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值，整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前 #result(timeout=None)
取得结果 #add_done_callback(fn)
回调函数
import time,random
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor def func(n):
time.sleep(random.randint(1,3))
return n*n if __name__ == '__main__':
p=ProcessPoolExecutor(max_workers=4)
list=[]
for i in range(10):
ret=p.submit(func,i)
list.append(ret)
print(ret.result())
p.shutdown()
for ret in list:
print(ret.result())
from concurrent.futures import ThreadPoolExecutor def func(n):
return n**2 if __name__ == '__main__':
t_p=ThreadPoolExecutor(max_workers=4)
list=[]
for i in range(10):
ret=t_p.submit(func,i)#异步提交任务
list.append(ret)
# print(ret.result()) #等待任务提交之后拿去结果,拿不到就柱塞,拿到了就继续 t_p.shutdown()
print("主进程结束")
for ret in list:
print(ret.result())
ThreadPoolExecutor
from concurrent.futures import ThreadPoolExecutor def func(n):
return n*n
if __name__ == '__main__':
t_p=ThreadPoolExecutor(max_workers=4) # for i in range(10):
# t_p.submit(func,i)
t_p.map(func,range(10)) #map取代了for+submit
map的用法
from concurrent.futures import ThreadPoolExecutor def get(n):
return n*n
def call(m):
print(">>",m)
print(m.result()) if __name__ == '__main__':
t_p=ThreadPoolExecutor(max_workers=4) for i in range(3):
t_p.submit(get,i).add_done_callback(call) """
结果
>> <Future at 0x294c1d0 state=finished returned int> #必须.result才能拿到结果
0
>> <Future at 0x294c1d0 state=finished returned int>
1
>> <Future at 0x294c1d0 state=finished returned int>
4
"""