Flask的线程，携程与并发
并发编程
# 1 操作系统发展史
# 2 进程基础：操作系统上运行的程序，是资源分配的最小单位
# 3 进程调度：时间片轮转法
# 4 并发和并行
# 5 同步，异步，阻塞，非阻塞
# 6 python创建进程
-两种方式：
-类继承：Process，重写run方法
-Process(target=任务)
-Process 属性和方法
-python启动一个进程：相当于，又开了一个python解释器，执行这个代码
-进程间数据是隔离的：进程间通信
# 7 进程同步：锁
# 8 进程间通信：Queue 队列
# 9 进程间数据共享
# 10 线程是什么：cpu调度的最小单位，真正执行程序的 每个进程下至少有一个主线程
# 11 创建多线程
-两种方式：Thread
# 12 GIL全局解释器锁：对Python由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行
-作用：一个进程下开启的多个线程，必须获得GIL锁，才能运行
-为什么有呢？
-当年没有多核，为了处理方便，就加了gil
-python垃圾回收机制，垃圾回收线程
-（cpython解释器）大的互斥锁，获得锁才能运行，释放锁，被别的线程抢到才能执行
# 13 守护线程
# 14 锁：互斥锁，递归锁，信号量，event事件
-互斥锁：作用，多线程并发操作变量时，保证数据安全
-递归锁，可重入锁：科学家吃面问题：死锁问题
-https://zhuanlan.zhihu.com/p/489305763
# 15 线程队列 queue
-线程间通信：共享变量
-线程间通信，使用queue，不需要使用锁了
# 16 线程池和进程池
# 17 协程：单线程下实现并发
# 18 gevent 实现协程(第三方实现)
-io操作，使用gevent的io
-同步：time.sleep()
# 19 asyncio实现协程
# 20 异步框架
# 有了gil锁为什么还要互斥锁？
多app应用（了解）
# 之前咱们写flask，都是实例化得到一个app对象，其实是可以使用多个app的
from flask import Flask
from werkzeug.serving import run_simple
from werkzeug.middleware.dispatcher import DispatcherMiddleware
app01 = Flask('app01')
app02 = Flask('app02')
@app01.route('/index')
def index():
return "app01"
@app02.route('/index2')
def index2():
return "app2"
dm = DispatcherMiddleware(app01, {'/sec': app02, })
if __name__ == '__main__':
run_simple('localhost', 5000, dm)
# 内部如何执行：
'''
1 请求来了，会执行dm(environ,start_response)
2 dm的__call__ 根据请求的地址，拿到不同的app，执行app(environ,start_response)--->Flask的__call__
'''
flask-script
# flask 的一个第三方插件，完成像django 的 python manage.py runserver 命令操作
# 下载：
pip3 install flask-script
Flask==2.2.2
Flask_Script==2.0.3
# django 中自定义命令
-第一步：在app中新建包：management
-第二步：在management下新建包：commands
-第三步：commands新建py文件，py文件名就是命令名 init.py
-第四步：init.py写入
from django.core.management.base import BaseCommand, CommandError
class Command(BaseCommand):
def add_arguments(self, parser):
parser.add_argument('--name', type=str) # 指令接受的参数列表，参数名左边有两个减号，可以添加类型限制
def handle(self, *args, **options):
name = options['name']
# 执行这个命令的逻辑是什么
# python manage.py init --name=lqz
from flask import Flask
from flask_script import Manager
app = Flask('app01')
# 使用第三方模块
manager = Manager(app)
# 自定制命令
@manager.command
def custom(arg):
"""
自定义命令
python manage.py custom 123
"""
print(arg)
@manager.option('-n', '--name', dest='name')
@manager.option('-u', '--url', dest='url')
def cmd(name, url):
"""
自定义命令（-n也可以写成--name）
执行： python manage.py cmd -n lqz -u http://www.oldboyedu.com
执行： python manage.py cmd --name lqz --url http://www.oldboyedu.com
"""
print(name, url)
# 后期可以自己定制一些命令
@app.route('/index')
def index():
return "app01"
if __name__ == '__main__':
manager.run()
导出项目依赖
# 之前学过：
# 虚拟环境：只装了该项目的模块
pip freeze > requirements.txt
# 使用真实环境导出依赖，会把所有都导出，可能会有问题，导出太多
- 项目依赖 pip3 install pipreqs
- 生成依赖文件：pipreqs ./ --encoding=utf8
- 安装依赖文件：pip3 install -r requirements.txt
函数和方法
# 函数就是普通函数，有几个值就要传几个值
# 方法[面向对象]是绑定给对象，类，绑定给谁谁来调用，会自动传值，谁来调用就会把谁传入
#总结：只要能自动传值，就是方法，有几个值传几个值就是函数
# 就是个函数
def add(a, b):
return a + b
class Person:
# 方法：绑定给对象的【不一定是方法】
def speak(self):
print('人说话')
@classmethod
def test(cls):
print('类的绑定方法')
@staticmethod
def ttt():
print('static')
p = Person()
# p.speak() # 能自动传值
# 如何确定到底是函数还是方法
from types import MethodType, FunctionType
print(isinstance(add, MethodType)) # False add 是个函数，不是方法
print(isinstance(add, FunctionType)) # True
print(isinstance(p.speak, MethodType)) # 方法
print(isinstance(p.speak, FunctionType)) # 不是函数
print(isinstance(Person.speak, FunctionType)) # 类来调用，它就是普通函数，有几个值就要传几个值
print(isinstance(Person.speak, MethodType)) # 不是方法了
Person.speak(p) # 普通函数
print(isinstance(Person.test, FunctionType)) # 不是函数
print(isinstance(Person.test, MethodType)) # 类来调用，类的绑定方法
print(isinstance(p.test, FunctionType)) # 不是函数
print(isinstance(p.test, MethodType)) # 对象来调用，类的绑定方法
Person.test()
print(isinstance(p.ttt, FunctionType)) # 静态方法，本质就是个函数，有几个值就要传几个值
print(isinstance(p.ttt, MethodType))
偏函数
# python内置给咱们一个偏函数，可以把函数包裹一下，提前传参
from functools import partial
def add(a, b, c):
return a + b + c
# 正常使用
# res=add(4,5,6)
# print(res)
# 使用偏函数,提前传值
res = partial(add, 4, 5)
print(res) # functools.partial(<function add at 0x000002C4025C71F0>, 4)
print(res(6))
threading.local
# threading.local 对象
# 多个线程操作同一个变量，如果不加锁，会出现数据错乱问题
# 作用：
线程变量，意思是threading.local中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。threading.local为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量
# 但是 多个线程同时操作 threading.local 对象 就不会出现数据错乱
-java：ThreadLocal
-python：threading.local
###不使用local对象
# 不用local,会出现数据错乱问题，除非加锁解决
# from threading import Thread
# import time
# from threading import Lock
#
# lqz = -1
# lock = Lock()
#
# def task():
# lock.acquire()
# global lqz
# tem = lqz
# time.sleep(0.0001)
# lqz = tem + 1
# print('---', lqz)
#
# lock.release()
#
#
# for i in range(10):
# t = Thread(target=task)
# t.start()
#
# print(lqz)
####演示2
# from threading import Thread
# import time
# from threading import Lock
# lock = Lock()
# lqz = -1
# def task(arg):
# # lock.acquire()
# global lqz
# lqz = arg
# time.sleep(0.01)
# print(lqz)
# # lock.release()
#
# for i in range(10):
# t = Thread(target=task,args=(i,))
# t.start()
# 使用local
from threading import Thread,get_ident
from threading import local
import time
# 特殊的对象
lqz = local()
def task(arg):
# 对象.val = 1/2/3/4/5
lqz.value = arg
time.sleep(0.1)
print('第：%s条线程的值为：%s'%(get_ident(),lqz.value))
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
自定义local支持线程和协程
# flask 的request，和session 都是全局的，但是我们在不同的视图函数中使用的 是正对于当前这次请求的对象，它的底层就是基于local写的
# flask部署支持多进程线程架构，也支持协程架构，flask内部重写了local，让它支持线程和协程
# local的本质是如何实现的
-变量对其他线程而言是隔离的
-local： {'线程id号':{}}
-设置值：
-线程1：local.val='lqz' ---> {'线程1id号':{val:lqz},}
-线程2：local.val='pyy' ---> {'线程1id号':{val:lqz},'线程2id号':{val:pyy},}
-取值：
-线程1：print(local.val) ---->l={'线程1id号':{val:lqz},'线程2id号':{val:pyy},}--》先当前线程的id号：get_ident() l[get_ident(线程1)]['val']
-线程2：print(local.val) ---->l={'线程1id号':{val:lqz},'线程2id号':{val:pyy},}--》先当前线程的id号：get_ident() l[get_ident(线程2)]['val']
# 1 通过字典自定义threading.local
# from threading import get_ident, Thread
# import time
#
# storage = {}
#
#
# def set(k, v):
# ident = get_ident() # 当前线程id号
# if ident in storage: #如果当前线程id号在字典中，表示修改值，直接改即可
# storage[ident][k] = v #
# else: #新增
# storage[ident] = {k: v}
#
#
# def get(k):
# ident = get_ident()
# return storage[ident][k]
#
#
# def task(arg):
# set('val', arg)
# v = get('val')
# time.sleep(0.01)
# print(v)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# # 2 面向对象版
# from threading import get_ident, Thread
# import time
#
#
# class Local(object):
# storage = {}
#
# def set(self, k, v):
# ident = get_ident()
# if ident in Local.storage:
# Local.storage[ident][k] = v
# else:
# Local.storage[ident] = {k: v}
#
# def get(self, k):
# ident = get_ident()
# return Local.storage[ident][k]
#
#
# obj = Local()
#
#
# def task(arg):
# obj.set('val', arg)
# v = obj.get('val')
# time.sleep(0.01)
# print(v)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 3 重写类的 __setattr__ __getattr
# from threading import get_ident, Thread
# import time
#
#
# class Local(object):
# storage = {}
#
# def __setattr__(self, k, v):
# ident = get_ident()
# if ident in Local.storage:
# Local.storage[ident][k] = v
# else:
# Local.storage[ident] = {k: v}
#
# def __getattr__(self, k):
# ident = get_ident()
# return Local.storage[ident][k]
#
#
# obj = Local() # 多个local对象公用一个storage
#
# def task(arg):
# obj.val = arg
# v = obj.val
# time.sleep(0.01)
# print(v)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 4 每个对象有自己的存储空间（字典）
# 取值：对象.属性，如果没有属性会触发 __getattr__
# 设置值：对象.属性='值'，如果属性不存在，会触发 __setattr__
# 如果属性有，直接就拿回来了
# from threading import get_ident, Thread
# import time
#
#
# class Local(object):
# def __init__(self):
# # self.storage = {} # 只要self.属性，就会调用 __setattr__，内部又掉了self.storage--->递归了
# #类来调用对象的绑定方法__setattr__，这个方法就会变成函数，有几个值就要传几个值
# # 本质就是完成 self.storage = {} 要完成的事，但是不会触发递归调用
# object.__setattr__(self, 'storage', {})
# # setattr(self,'storage', {}) # 反射的方式设置值，也会触发递归
#
# def __setattr__(self, k, v):
# ident = get_ident()
# if ident in self.storage:
# self.storage[ident][k] = v
# else:
# self.storage[ident] = {k: v}
#
# def __getattr__(self, k):
# ident = get_ident()
# return self.storage[ident][k]
#
#
# obj = Local() # 每个local对象，用自己的字典
#
#
# def task(arg):
# obj.val = arg
# v = obj.val
# time.sleep(0.01)
# print(v)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 6 兼容线程和协程
try:
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
from threading import Thread
import time
class Local(object):
def __init__(self):
# self.storage = {} # 只要self.属性，就会调用 __setattr__，内部又掉了self.storage--->递归了
# 类来调用对象的绑定方法__setattr__，这个方法就会变成函数，有几个值就要传几个值
# 本质就是完成 self.storage = {} 要完成的事，但是不会触发递归调用
object.__setattr__(self, 'storage', {})
# setattr(self,'storage', {}) # 反射的方式设置值，也会触发递归
def __setattr__(self, k, v):
ident = get_ident()
if ident in self.storage:
self.storage[ident][k] = v
else:
self.storage[ident] = {k: v}
def __getattr__(self, k):
ident = get_ident() # 在协程中，gevent中是获取协程id号，如果在线程中，获取的是线程id号
return self.storage[ident][k]
obj = Local() # 每个local对象，用自己的字典
def task(arg):
obj.val = arg
v = obj.val
time.sleep(0.01)
print(v)
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
flask 自定义的local，支持线程和协程
class Local(object):
def __init__(self):
object.__setattr__(self, "__storage__", {})
object.__setattr__(self, "__ident_func__", get_ident)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
flask请求上下文分析
# 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
# environ:http请求拆成了字典
# ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
ctx = self.request_context(environ)
error = None
try:
try:
#ctx RequestContext类 push方法
ctx.push()
# 匹配成路由后，执行视图函数
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
# RequestContext :ctx.push
def push(self):
# _request_ctx_stack = LocalStack() ---》push(ctx对象)--》ctx:request，session，app
_request_ctx_stack.push(self)
#session相关的
if self.session is None:
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
self.session = session_interface.make_null_session(self.app)
# 路由匹配相关的
if self.url_adapter is not None:
self.match_request()
# LocalStack() push --->obj 是ctx对象
def push(self, obj):
#self._local _local 就是咱们刚刚自己写的Local的对象---》LocalStack的init初始化的_local---》self._local = Local()---》Local对象可以根据线程区分数据
rv = getattr(self._local, "stack", None)
if rv is None:
rv = []
self._local.stack = rv # self._local.stack 根据不同线程用的是自己的数据
rv.append(obj) # self._local.stack.append(obj)
# {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
return rv
# 再往后执行，就会进入到路由匹配，执行视图函数
# request = LocalProxy(partial(_lookup_req_object, "request"))
# LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
视图函数中：print(request.method)
# print(request) 执行LocalProxy类的__str__方法
# request.method 执行LocalProxy类的__getattr__
def __getattr__(self, name): #name 是method
# self._get_current_object() 就是当次请求的request
return getattr(self._get_current_object(), name)
# LocalProxy类的方法_get_current_object
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
# self.__local 是在 LocalProxy 类实例化的时候传入的local
# 在这里实例化的：request = LocalProxy(partial(_lookup_req_object, "request"))
# local 是 partial(_lookup_req_object, "request")
#_lookup_req_object ，name=request
def _lookup_req_object(name):
top = _request_ctx_stack.top # 取出了ctx，是当前线程的ctx
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name) #从ctx中反射出request，当次请求的request
请求上下文执行流程（ctx）：
-0 flask项目一启动，有6个全局变量
-_request_ctx_stack：LocalStack对象
-_app_ctx_stack ：LocalStack对象
-request ： LocalProxy对象
-session ： LocalProxy对象
-1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
-2 wsgi_app()
-2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session,flash,当前app对象
-2.2 执行： ctx.push()：RequestContext对象的push方法
-2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
-2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
-2.2.3 push方法源码：
def push(self, obj):
#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
#Local()，flask封装的支持线程和协程的local对象
# 一开始取不到stack，返回None
rv = getattr(self._local, "stack", None)
if rv is None:
#走到这，self._local.stack=[],rv=self._local.stack
self._local.stack = rv = []
# 把ctx放到了列表中
#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
rv.append(obj)
return rv
-3 如果在视图函数中使用request对象，比如：print(request)
-3.1 会调用request对象的__str__方法，request类是：LocalProxy
-3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
-3.2.1 内部执行self._get_current_object()
-3.2.2 _get_current_object()方法的源码如下：
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
#self.__local() 在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
# 用了隐藏属性
#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
#这个地方的返回值就是request对象(当此请求的request，没有乱)
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
-3.2.3 _lookup_req_object函数源码如下：
def _lookup_req_object(name):
#name是'request'字符串
#top方法是把第二步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
#通过反射，去ctx中把request对象返回
return getattr(top, name)
-3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
-4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
-5 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉
其他的东西：
-session:
-请求来了opensession
-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
if self.session is None:
#self是ctx，ctx中有个app就是flask对象， self.app.session_interface也就是它：SecureCookieSessionInterface()
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
#经过上面还是None的话，生成了个空session
self.session = session_interface.make_null_session(self.app)
-请求走了savesession
-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
-请求扩展相关
before_first_request，before_request，after_request依次执行
-flask有一个请求上下文，一个应用上下文
-ctx:
-是：RequestContext对象:封装了request和session
-调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
-app_ctx:
-是：AppContext(self) 对象：封装了当前的app和g
-调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
-g是个什么鬼？
专门用来存储用户信息的g对象，g的全称的为global
g对象在一次请求中的所有的代码的地方，都是可以使用的
-代理模式
-request和session就是代理对象，用的就是代理模式
