内容概要
- GIL全局解释器锁
- 验证GIL的存在及功能
- 验证python多线程是否有用
- 死锁现象
- 进程池与线程池
- IO模型
内容详细
GIL全局解释器锁
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)
"""
1.python解释器其实有很多版本(默认肯定使用的是CPython)
Cpython、Jpython、pypython
在Cpython中GIL全局解释器锁其实也是一把互斥锁，主要用于阻止同一个进程下的多个线程同时被运行(python的多线程无法使用多核优势)
GIL肯定存在于CPython解释器中 主要原因就在于Cpython解释器的内存管理不是线程安全的
2.内存管理>>>垃圾回收机制
引用计数
标记清除
分代回收
"""
1.GIL是Cpython解释器的特点
2.python同一个进程内的多个线程无法利用多核优势(不能并行但是可以并发)
3.同一个进程内的多个线程要想运行必须先抢GIL锁
4.所有的解释型语言几乎都无法实现同一个进程下的多个线程同时被运行
验证GIL 的存在
from threading import Thread
import time
m = 100
def test():
global m
tmp = m
tmp -= 1
m = tmp
for i in range(100):
t = Thread(target=test)
t.start()
time.sleep(3)
print(m)
"""
同一个进程下的多个线程虽然有GIL的存在不会出现并行的效果
但是如果线程内有IO操作还是会造成数据的错乱 这个时候需要我们额外的添加互斥锁
"""
死锁现象
from threading import Thread, Lock
import time
A = Lock()
B = Lock()
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
A.acquire()
print('%s 抢到了A锁' % self.name) # current_thread().name 获取线程名称
B.acquire()
print('%s 抢到了B锁' % self.name)
time.sleep(1)
B.release()
print('%s 释放了B锁' % self.name)
A.release()
print('%s 释放了A锁' % self.name)
def func2(self):
B.acquire()
print('%s 抢到了B锁' % self.name)
A.acquire()
print('%s 抢到了A锁' % self.name)
A.release()
print('%s 释放了A锁' % self.name)
B.release()
print('%s 释放了B锁' % self.name)
for i in range(10):
obj = MyThread()
obj.start()
"""就算知道锁的特性及使用方式 也不要轻易的使用 因为容易产生死锁现象"""
python多线程是否没用
# 是否有用需要看情况而定(程序的类型)
# IO密集型
eg:四个任务 每个任务耗时10s
开设多进程没有太大的优势 10s+
遇到IO就需要切换 并且开设进程还需要申请内存空间和拷贝代码
开设多线程有优势
不需要消耗额外的资源 10s+
# 计算密集型
eg:四个任务 每个任务耗时10s
开设多进程可以利用多核优势 10s+
开设多线程无法利用多核优势 40s+
"""
多进程结合多线程
"""
"""IO密集型"""
# from multiprocessing import Process
# from threading import Thread
# import threading
# import os,time
# def work():
# time.sleep(2)
#
#
# if __name__ == '__main__':
# l=[]
# print(os.cpu_count()) #本机为6核
# start=time.time()
# for i in range(400):
# # p=Process(target=work) #耗时42.54s多,大部分时间耗费在创建进程上
# p=Thread(target=work) #耗时2.08s多
# l.append(p)
# p.start()
# for p in l:
# p.join()
# stop=time.time()
# print('run time is %s' %(stop-start))
"""计算密集型"""
from multiprocessing import Process
from threading import Thread
import os,time
def work():
res=0
for i in range(100000000):
res*=i
if __name__ == '__main__':
l=[]
print(os.cpu_count()) # 本机为6核
start=time.time()
for i in range(6):
# p=Process(target=work) #耗时5.35s多
p=Thread(target=work) #耗时23.37s多
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
进程池与线程池
思考:能否无限制的开设进程或者线程???
肯定是不能无限制开设的
如果单从技术层面上来说无限开设肯定是可以的并且是最高效的
但是从硬件层面上来说是无法实现的(硬件的发展永远赶不上软件的发展速度)
池
在保证计算机硬件不奔溃的前提下开设多进程和多线程
降低了程序的运行效率但是保证了计算机硬件的安全
进程池与线程池
进程池:提前开设了固定个数的进程 之后反复调用这些进程完成工作(后续不再开设新的)
线程池:提前开设了固定个数的线程 之后反复调用这些线程完成工作(后续不再开设新的)
进程池与线程池的基本使用
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
import os
# 创建进程池与线程池
# pool = ThreadPoolExecutor(5) # 可以自定义线程数 也可以采用默认策略
pool = ProcessPoolExecutor(5) # 可以自定义线程数 也可以采用默认策略
# 定义一个任务
def task(n):
print(n, os.getpid())
time.sleep(2)
return '>>>:%s' % n ** 2
# 定义一个回调函数:异步提交完之后有结果自动调用该函数
def call_back(a):
print('异步回调函数:%s' % a.result())
# 朝线程池中提交任务
# obj_list = []
for i in range(20):
res = pool.submit(task, i).add_done_callback(call_back) # 异步提交
# obj_list.append(res)
"""
同步:提交完任务之后原地等待任务的返回结果 期间不做任何事
异步:提交完任务之后不愿地等待任务的返回结果 结果由异步回调机制自动反馈
"""
# 等待线程池中所有的任务执行完毕之后 再获取各自任务的结果
# pool.shutdown()
# for i in obj_list:
# print(i.result()) # 获取任务的执行结果 同步
在windows电脑中如果是进程池的使用也需要在__main__下面
协程理论与实操
进程
资源单位
线程
工作单位
协程
是程序员单方面意淫出来的名词>>>:单线程下实现并发
# CPU被剥夺的条件
1.程序长时间占用
2.程序进入IO操作
# 并发
切换+保存状态
以往学习的是:多个任务(进程、线程)来回切换
# 欺骗CPU的行为
单线程下我们如果能够自己检测IO操作并且自己实现代码层面的切换
那么对于CPU而言我们这个程序就没有IO操作，CPU会尽可能的被占用
"""代码层面"""
第三方gevent模块:能够自主监测IO行为并切换
from gevent import monkey;monkey.patch_all() # 固定代码格式加上之后才能检测所有的IO行为
from gevent import spawn
import time
def play(name):
print('%s play 1' % name)
time.sleep(5)
print('%s play 2' % name)
def eat(name):
print('%s eat 1' % name)
time.sleep(3)
print('%s eat 2' % name)
start = time.time()
# play('jason') # 正常的同步调用
# eat('jason') # 正常的同步调用
g1 = spawn(play, 'jason') # 异步提交
g2 = spawn(eat, 'jason') # 异步提交
g1.join()
g2.join() # 等待被监测的任务运行完毕
print('主', time.time() - start) # 单线程下实现并发，提升效率
协程实现TCP服务端并发的效果
# 并发效果:一个服务端可以同时服务多个客户端
import socket
from gevent import monkey;monkey.patch_all()
from gevent import spawn
def talk(sock):
while True:
try:
data = sock.recv(1024)
if len(data) == 0:break
print(data)
sock.send(data+b'hello baby!')
except ConnectionResetError as e:
print(e)
sock.close()
break
def servers():
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen()
while True:
sock, addr = server.accept()
spawn(talk,sock)
g1 = spawn(servers)
g1.join()
# 客户端开设几百个线程发消息即可
"""
最牛逼的情况:多进程下开设多线程 多线程下开设协程
我们以后可能自己动手写的不多 一般都是使用别人封装好的模块或框架
"""
IO模型简介
"""理论为主 代码实现大部分为伪代码(没有实际含义 仅为验证参考)"""
IO模型研究的主要是网络IO(linux系统)
# 基本关键字
同步（synchronous） 大部分情况下会采用缩写的形式 sync
异步（asynchronous） async
阻塞（blocking）
非阻塞（non-blocking）
# 研究的方向
Stevens在文章中一共比较了五种IO Model：
* blocking IO 阻塞IO
* nonblocking IO 非阻塞IO
* IO multiplexing IO多路复用
* signal driven IO 信号驱动IO
* asynchronous IO 异步IO
由signal driven IO（信号驱动IO）在实际中并不常用，所以主要介绍其余四种IO Model
四种IO模型简介
# 1.阻塞IO
最为常见的一种IO模型 有两个等待的阶段(wait for data、copy data)
# 2.非阻塞IO
系统调用阶段变为了非阻塞(轮训) 有一个等待的阶段(copy data)
轮训的阶段是比较消耗资源的
# 3.多路复用IO
利用select或者epoll来监管多个程序 一旦某个程序需要的数据存在于内存中了 那么立刻通知该程序去取即可
# 4.异步IO
只需要发起一次系统调用 之后无需频繁发送 有结果并准备好之后会通过异步回调机制反馈给调用者
