摘要:在我之前寫的中源碼的深究和理解一文中解釋了如何支持多線程主要通過兩個類來實現(xiàn)和在中有兩個屬性和后者用來獲取線程從而區(qū)分不同線程發(fā)來的請求這次要說的是如何開啟多線程先從這個方法看起會進入這個函數(shù)經(jīng)過判斷和設(shè)置后進入這個函數(shù)看下源碼
在我之前寫的《flask中current_app、g、request、session源碼的深究和理解》一文中解釋了flask如何支持多線程
主要通過兩個類來實現(xiàn),LocalStack和Local,在Local中有兩個屬性,__storage__和__ident_func__,后者用來獲取線程id,從而區(qū)分不同線程發(fā)來的請求
這次要說的是flask如何開啟多線程
先從app.run()這個方法看起
def run(self, host=None, port=None, debug=None, **options): from werkzeug.serving import run_simple if host is None: host = "127.0.0.1" if port is None: server_name = self.config["SERVER_NAME"] if server_name and ":" in server_name: port = int(server_name.rsplit(":", 1)[1]) else: port = 5000 if debug is not None: self.debug = bool(debug) options.setdefault("use_reloader", self.debug) options.setdefault("use_debugger", self.debug) try: run_simple(host, port, self, **options) #會進入這個函數(shù) finally: # reset the first request information if the development server # reset normally. This makes it possible to restart the server # without reloader and that stuff from an interactive shell. self._got_first_request = False
經(jīng)過判斷和設(shè)置后進入run_simple()這個函數(shù),看下源碼
def run_simple(hostname, port, application, use_reloader=False,
use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type="auto", threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): """Start a WSGI application. Optional features include a reloader, multithreading and fork support. This function has a command-line interface too:: python -m werkzeug.serving --help .. versionadded:: 0.5 `static_files` was added to simplify serving of static files as well as `passthrough_errors`. .. versionadded:: 0.6 support for SSL was added. .. versionadded:: 0.8 Added support for automatically loading a SSL context from certificate file and private key. .. versionadded:: 0.9 Added command-line interface. .. versionadded:: 0.10 Improved the reloader and added support for changing the backend through the `reloader_type` parameter. See :ref:`reloader` for more information. :param hostname: The host for the application. eg: ``"localhost"`` :param port: The port for the server. eg: ``8080`` :param application: the WSGI application to execute :param use_reloader: should the server automatically restart the python process if modules were changed? :param use_debugger: should the werkzeug debugging system be used? :param use_evalex: should the exception evaluation feature be enabled? :param extra_files: a list of files the reloader should watch additionally to the modules. For example configuration files. :param reloader_interval: the interval for the reloader in seconds. :param reloader_type: the type of reloader to use. The default is auto detection. Valid values are ``"stat"`` and ``"watchdog"``. See :ref:`reloader` for more information. :param threaded: should the process handle each request in a separate thread? :param processes: if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes. :param request_handler: optional parameter that can be used to replace the default one. You can use this to replace it with a different :class:`~BaseHTTPServer.BaseHTTPRequestHandler` subclass. :param static_files: a list or dict of paths for static files. This works exactly like :class:`SharedDataMiddleware`, it"s actually just wrapping the application in that middleware before serving. :param passthrough_errors: set this to `True` to disable the error catching. This means that the server will die on errors but it can be useful to hook debuggers in (pdb etc.) :param ssl_context: an SSL context for the connection. Either an :class:`ssl.SSLContext`, a tuple in the form ``(cert_file, pkey_file)``, the string ``"adhoc"`` if the server should automatically create one, or ``None`` to disable SSL (which is the default). """ if not isinstance(port, int): raise TypeError("port must be an integer") if use_debugger: from werkzeug.debug import DebuggedApplication application = DebuggedApplication(application, use_evalex) if static_files: from werkzeug.wsgi import SharedDataMiddleware application = SharedDataMiddleware(application, static_files) def log_startup(sock): display_hostname = hostname not in ("", "*") and hostname or "localhost" if ":" in display_hostname: display_hostname = "[%s]" % display_hostname quit_msg = "(Press CTRL+C to quit)" port = sock.getsockname()[1] _log("info", " * Running on %s://%s:%d/ %s", ssl_context is None and "http" or "https", display_hostname, port, quit_msg) def inner(): try: fd = int(os.environ["WERKZEUG_SERVER_FD"]) except (LookupError, ValueError): fd = None srv = make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context, fd=fd) if fd is None: log_startup(srv.socket) srv.serve_forever() if use_reloader: # If we"re not running already in the subprocess that is the # reloader we want to open up a socket early to make sure the # port is actually available. if os.environ.get("WERKZEUG_RUN_MAIN") != "true": if port == 0 and not can_open_by_fd: raise ValueError("Cannot bind to a random port with enabled " "reloader if the Python interpreter does " "not support socket opening by fd.") # Create and destroy a socket so that any exceptions are # raised before we spawn a separate Python interpreter and # lose this ability. address_family = select_ip_version(hostname, port) s = socket.socket(address_family, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(get_sockaddr(hostname, port, address_family)) if hasattr(s, "set_inheritable"): s.set_inheritable(True) # If we can open the socket by file descriptor, then we can just # reuse this one and our socket will survive the restarts. if can_open_by_fd: os.environ["WERKZEUG_SERVER_FD"] = str(s.fileno()) s.listen(LISTEN_QUEUE) log_startup(s) else: s.close() # Do not use relative imports, otherwise "python -m werkzeug.serving" # breaks. from werkzeug._reloader import run_with_reloader run_with_reloader(inner, extra_files, reloader_interval, reloader_type) else: inner() #默認會執(zhí)行
還是經(jīng)過一系列判斷后默認會進入inner()函數(shù),這個函數(shù)定義在run_simple()內(nèi),屬于閉包,inner()中會執(zhí)行make_server()這個函數(shù),看下源碼:
def make_server(host=None, port=None, app=None, threaded=False, processes=1,
request_handler=None, passthrough_errors=False, ssl_context=None, fd=None): """Create a new server instance that is either threaded, or forks or just processes one request after another. """ if threaded and processes > 1: raise ValueError("cannot have a multithreaded and " "multi process server.") elif threaded: return ThreadedWSGIServer(host, port, app, request_handler, passthrough_errors, ssl_context, fd=fd) elif processes > 1: return ForkingWSGIServer(host, port, app, processes, request_handler, passthrough_errors, ssl_context, fd=fd) else: return BaseWSGIServer(host, port, app, request_handler, passthrough_errors, ssl_context, fd=fd)
看到這也很明白了,想要配置多線程或者多進程,則需要設(shè)置threaded或processes這兩個參數(shù),而這兩個參數(shù)是從app.run()中傳遞過來的:
app.run(**options) ---> run_simple(threaded,processes) ---> make_server(threaded,processes)
默認情況下flask是單線程,單進程的,想要開啟只需要在run中傳入對應(yīng)的參數(shù):app.run(threaded=True)即可.
從make_server中可知,flask提供了三種server:ThreadedWSGIServer,ForkingWSGIServer,BaseWSGIServer,默認情況下是BaseWSGIServer
以線程為例,看下ThreadedWSGIServer這個類:
class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer): #繼承自ThreadingMixIn, BaseWSGIServer
"""A WSGI server that does threading.""" multithread = True daemon_threads = True
ThreadingMixIn = socketserver.ThreadingMixIn
class ThreadingMixIn:
"""Mix-in class to handle each request in a new thread.""" # Decides how threads will act upon termination of the # main process daemon_threads = False def process_request_thread(self, request, client_address): """Same as in BaseServer but as a thread. In addition, exception handling is done here. """ try: self.finish_request(request, client_address) self.shutdown_request(request) except: self.handle_error(request, client_address) self.shutdown_request(request) def process_request(self, request, client_address): """Start a new thread to process the request.""" t = threading.Thread(target = self.process_request_thread, args = (request, client_address)) t.daemon = self.daemon_threads t.start()
process_request就是對每個請求產(chǎn)生一個新的線程來處理
最后寫一個非常簡單的應(yīng)用來驗證以上說法:
from flask import Flask
from flask import _request_ctx_stack
app = Flask(__name__)
@app.route("/")
def index():
print(_request_ctx_stack._local.__ident_func__()) while True: pass return "hello
"
app.run() #如果需要開啟多線程則app.run(threaded=True)
_request_ctx_stack._local.__ident_func__()對應(yīng)這get_ident()這個函數(shù),返回當(dāng)前線程id,為什么要在后面加上while True這句呢,我們看下get_ident()這個函數(shù)的說明:
Return a non-zero integer that uniquely identifies the current thread amongst other threads that exist simultaneously. This may be used to identify per-thread resources. Even though on some platforms threads identities may appear to be allocated consecutive numbers starting at 1, this behavior should not be relied upon, and the number should be seen purely as a magic cookie. A thread"s identity may be reused for another thread after it exits.
關(guān)鍵字我已經(jīng)加粗了,線程id會在線程結(jié)束后重復(fù)利用,所以我在路由函數(shù)中加了這個死循環(huán)來阻塞請求以便于觀察到不同的id,這就會產(chǎn)生兩種情況:
1.沒開啟多線程的情況下,一次請求過來,服務(wù)器直接阻塞,并且之后的其他請求也都阻塞
2.開啟多線程情況下,每次都會打印出不同的線程id
第一種情況
Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
139623180527360
第二種情況
Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
140315469436672
140315477829376
140315486222080
140315316901632
140315105163008
140315096770304
140315088377600
結(jié)果顯而易見
綜上所述:flask支持多線程,但默認沒開啟,其次app.run()只適用于開發(fā)環(huán)境,生產(chǎn)環(huán)境下可以使用uWSGI,Gunicorn等web服務(wù)器
文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址:http://specialneedsforspecialkids.com/yun/44732.html
摘要:示例如下靜態(tài)路由使用動態(tài)變量的路由未指定變量類型使用動態(tài)變量的路由指定變量類型指定的路由變量,可以作為被裝飾的函數(shù)參數(shù)傳入進來。 開始決定認真的在網(wǎng)上寫一些東西,主要原因還是在于希望能提升學(xué)習(xí)效果。雖說python寫了有幾年,但是web后端框架的確沒怎么接觸過,買了本狗書寥寥草草的過了一遍,發(fā)現(xiàn)很多東西還是理解不深,真的是好記性不如爛筆頭,知識也要從基礎(chǔ)開始,退回來好好看看官方文檔,再...
摘要:前面兩篇講明了怎么支持多線程以及怎么開啟多線程的這篇來講講當(dāng)后端接收到請求后是怎么一步步封裝的類中的當(dāng)應(yīng)用啟動后會通過接收請求中返回的是方法主要做了兩件事情第一件事是通過的另一個方法返回得到了一個封裝好的對象然后調(diào)用中的在最后調(diào)用了將請求對 前面兩篇講明了flask怎么支持多線程以及怎么開啟多線程的,這篇來講講當(dāng)后端接收到請求后是怎么一步步封裝的 Flask類中的wsgi_app()當(dāng)...
摘要:函數(shù)攜帶目的地址主題郵件體模板和一組關(guān)鍵字參數(shù)。許多擴展操作是在假設(shè)有活動的應(yīng)用程序和請求上下文的情況下進行的。但是當(dāng)函數(shù)在一個不同的線程上執(zhí)行,應(yīng)用程序上下文需要人為地創(chuàng)建使用。例如,執(zhí)行函數(shù)可以將郵件發(fā)送到的任務(wù)隊列中。 許多類型的應(yīng)用程序都會在某些事件發(fā)生的時候通知用戶,常用的溝通方法就是電子郵件。盡管在Flask應(yīng)用程序中,可以使用Python標準庫中的smtplib包來發(fā)送電...
摘要:從存儲的字符串表示中檢索原始對象的過程稱為。這稱為命名空間。如果需要八進制或十六進制表示,請使用內(nèi)置函數(shù)或。和有什么區(qū)別返回對象,而返回列表,并使用相同的內(nèi)存,無論范圍大小是多少。它提供了靈活性,并允許開發(fā)人員為他們的項目使用正確的工具。 ...
摘要:有兩類應(yīng)用級和請求級。一個響應(yīng)中非常重要的部分是狀態(tài)碼,默認設(shè)置來指示請求已經(jīng)成功處理。重定向通常由響應(yīng)狀態(tài)碼注明并且重定向的由頭部的給出。因為這些變化,應(yīng)用程序獲得一組基本的命令行選項。運行顯示可用信息在應(yīng)用程序上下文的內(nèi)部運行一個。 5、請求-響應(yīng)循環(huán) 現(xiàn)在你已經(jīng)玩過一個基本的Flask應(yīng)用程序,你也許想要知道更多關(guān)于Flask如何施展魔力。下面章節(jié)描述了一些框架設(shè)計方面的特點。...
閱讀 2882·2021-11-22 09:34
閱讀 1212·2021-11-19 09:40
閱讀 3335·2021-10-14 09:43
閱讀 3566·2021-09-23 11:22
閱讀 1601·2021-08-31 09:39
閱讀 880·2019-08-30 15:55
閱讀 1414·2019-08-30 15:54
閱讀 854·2019-08-30 15:53