首页 > 其他分享 >flask-05

flask-05

时间：2022-12-14 22:14:45浏览次数：45  
标签：__ ident 05 flask self 线程 local def

一、并发编程

  1. 操作系统发展史
  2. 进程基础：操作系统上运行的程序，是资源分配的最小单位
  3. 进程调度：时间片轮转法
  4. 并发和并行
  5. 同步，异步，阻塞，非阻塞
  6. python创建进程
    1. 两种方式：
      1. 类继承：Process，重写run方法
      2. Process(target=任务)
    2. Process 属性和方法
    3. python启动一个进程：相当于，又开了一个python解释器，执行这个代码
    4. 进程间数据是隔离的：进程间通信
  7. 进程同步：锁
  8. 进程间通信：Queue 队列
  9. 进程间数据共享
  10. 线程是什么：cpu调度的最小单位，真正执行程序的   每个进程下至少有一个主线程
  11. 创建多线程
    1. 两种方式：Thread
  12. GIL全局解释器锁：对Python由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行
  13. 作用：一个进程下开启的多个线程，必须获得GIL锁，才能运行
    1. 为什么有呢？
      1. 当年没有多核，为了处理方便，就加了gil  python垃圾回收机制，垃圾回收线程
    2. （cpython解释器）大的互斥锁，获得锁才能运行，释放锁，被别的线程抢到才能执行
  14. 守护线程
  15. 锁：互斥锁，递归锁，信号量，event事件
    1. 互斥锁：作用，多线程并发操作变量时，保证数据安全
    2. 递归锁，可重入锁：科学家吃面问题：死锁问题
  16. 线程队列  queue
    1. 线程间通信：共享变量
    2. 线程间通信，使用queue，不需要使用锁了
  17. 线程池和进程池
  18. 协程：单线程下实现并发
  19. gevent 实现协程(第三方实现)
    1. io操作，使用gevent的io
    2. 同步：time.sleep()
  20. asyncio实现协程
  21. 异步框架

二、多app应用（了解）

  • 之前咱们写flask，都是实例化得到一个app对象，其实是可以使用多个app的

内部如何执行?

  • 请求来了，会执行dm(environ,start_response)
  • dm的__call__ 根据请求的地址，拿到不同的app，执行
  • app(environ,start_response)——>Flask的__call__
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)

三、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=curry
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(2,3,4)
# print(res)


# 使用偏函数,提前传值
res = partial(add,3,4)
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请求上下文分析

研究flask内部是怎么运行的

请求来了——>app()——>Flask.__call__——>self.wsgi_app(environ, start_response)

  • def wsgi_app(self, environ, start_response):
    • environ:http请求拆成了字典
    • ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
    def wsgi_app(self, environ, start_response):
        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
  • （self）就是ctx对象
  • 先组装成ctx对象，然后先执行open_session执行session相关的，再执行路由相关的
  • 匹配路由成功后，执行视图函数，视图函数出错捕获了，不出错return出去
 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()
  • self._local = Local()——>Local对象可以根据线程区分数据 
  • self._local.stack 根据不同线程用的是自己的数据
  • self._local.stack.append(obj)   这里把obj追加进去了 
  • 以线程id号做区分——>{'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[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"))
    • 这里的request是LocalProxy的对象
  • LocalProxy 代理类（代理模式）——>method——>代理类去当前线程的stack取出ctx，取出当时放进去的request
  • 打印的是当次的request，这样不会错乱
  • print(request) 执行LocalProxy类的__str__方法（做成了lambda）实际操作的是代理类
  • 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
  • 设置的时候，用object_类名__字段名，这是隐藏属性在里面用的时候就用__local

   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")

  • .top取出了ctx，是当前线程的ctx
  • return getattr(top, name)  从ctx中反射出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

所以在视图类中调用reuest.method就是当次请求的

虽然用的是全局的request对象，但是真正用的时候就是当次的request对象，因为它做了代理。session和g也是如此

标签：__,ident,05,flask,self,线程,local,def
From： https://www.cnblogs.com/zzjjpp/p/16982698.html

相关文章

  • P5405 [CTS2019]氪金手游
    链接：https://www.luogu.com.cn/problem/CF1284E题解：由于这是一个内外向树，不好做，先将它转化为内向树。转化后其实可算出第\(i\)在\(i\)子树前被抽中的概率：令子树和为\(SZ......
  • ogg目标库应用进程异常，告警OGG-00519、ORA-02443
    问题描述：ogg目标库应用进程异常，告警OGG-00519、ORA-02443，如下所示：场景说明：源端表中存在一个约束，约束名为系统自定义，该约束在目标端未能查找，所以便在源库将其删除，结果就出现......
  • 【《硬件架构的艺术》读书笔记】05 低功耗设计（3）
    5.6在寄存器传输级降低功耗RTL完成时80%的功耗就已经确定，后端不能解决所有功耗问题。综合前RTL阶段就应讲与功耗有关的所有问题解决。5.6.1状态机编码与解码格雷码在......
  • 【Flask】flask-script， 自定义local支持线程和协程
    目录1.多app应用2.flask-script3.导出项目依赖4.函数和方法5.偏函数6.threading.local7.自定义local支持线程和协程8.flask请求上下文分析1.多app应用#之前咱......
  • flask博客项目之tinymce图片上传
     截图一张立马粘贴进来  点击发表，显示数据太长  不断撤退回到刚刚页面  删除大图，换成小图，上传方式  点击发表可以成功发表  数据库中查看，是把......
  • flask 框架使用
    https://blog.csdn.net/shifengboy/article/details/1142742711.安装flaskpipinstallflask2.简单上手一个最小的Flask应用如下:fromflaskimportFlaskapp=......
  • 005 计算机操作系统（什么是文件和应用程序）
    计算机五大组成控制器、运算器、存储器（CPU只和内存交互）、输入设备、输出设备什么是操作系统计算机只认识0和1（高低电压）a陈a-》0000也就是你新建一个文件，删除一个文件，都......
  • Jenkins实践指南-05-Jenkins pipeline 语法01
    3.Jenkinspipeline语法3.1pipeline组成  [作者：Surpassme]Jenkinspipeline是基于Groovy语言实现的一种DSL（领域特定语言），用于描述整条流水线是如何进行的。流水......
  • Flask请求与响应
    请求与响应#请求对象requestdefindex():print(request.method)#请求方式print(request.form)#post请求数据print(request.args)#get请求数......
  • P2057 [SHOI2007] 善意的投票
    传送门思路我们考虑将原本想同意的人连向源点，原本不同意的人连向汇点，流量皆为\(1\)。对于一对好朋友\(x,y\)，我们连接\((x,y)\)和\((y,x)\)双向边，流量皆为\(1\)......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99