Flask的线程，携程与并发

 

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就是代理对象，用的就是代理模式
posted @   Joseph-bright  阅读(405)  评论(0)  编辑  收藏  举报
相关博文：
· Flask的线程，携程与并发 (2)
· Flask的请求，响应简介
· flask-05
· 【Flask】flask-script， 自定义local支持线程和协程
· threading.local、请求上下文执行流程
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
历史上的今天：
2022-08-01 选课系统前戏
点击右上角即可分享
微信分享提示

目录导航