U
|
Z ±d ã @ s\ d dl mZmZ d dlZd dlmZ dZe ZG dd dZG dd dZ e Z
|
d d
|
Z dS ) é )ÚThreadÚLockN)Úcounté
|
c @ s$ e Zd Zdd Zdd Zdd ZdS )Ú WorkerThreadc C sH d | _ || _t | _| j ¡ t| jdd}dtt |_ |
|
¡ d S )NT)ÚtargetÚdaemonzTrio worker thread ) Ú_jobÚ _thread_cacher Ú _worker_lockÚacquirer Ú_workÚnextÚ name_counterÚnameÚstart)ÚselfZ thread_cacheÚthread© r úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_core/_thread_cache.pyÚ__init__, s
|
zWorkerThread.__init__c C s2 | j \}}d | _ t |¡}d | jj| < || d S ©N)r ÚoutcomeÚcapturer
|
Ú _idle_workers)r ÚfnÚdeliverÚresultr r r Ú _handle_job; s
|
|
|
zWorkerThread._handle_jobc C sJ | j jtdr| ¡ q z| jj| = W n tk
|
r> Y q Y q X d S q d S )N)Útimeout)r r Ú IDLE_TIMEOUTr r
|
r ÚKeyError©r r r r r H s
|
|
zWorkerThread._workN)Ú__name__Ú
|
__module__Ú __qualname__r r r r r r r r + s r c @ s e Zd Zdd Zdd ZdS )Ú ThreadCachec C s
|
i | _ d S r )r r" r r r r ` s zThreadCache.__init__c C sH z| j ¡ \}}W n tk
|
r. t| }Y nX ||f|_|j ¡ d S r )r Úpopitemr! r r r Úrelease)r r r ZworkerÚ_r r r Ústart_thread_soonc s
|
z ThreadCache.start_thread_soonN)r# r$ r% r r* r r r r r& _ s r& c C s t | |¡ dS )uÈ Runs ``deliver(outcome.capture(fn))`` in a worker thread.
|
|
Generally ``fn`` does some blocking work, and ``deliver`` delivers the
|
result back to whoever is interested.
|
|
This is a low-level, no-frills interface, very similar to using
|
`threading.Thread` to spawn a thread directly. The main difference is
|
that this function tries to re-use threads when possible, so it can be
|
a bit faster than `threading.Thread`.
|
|
Worker threads have the `~threading.Thread.daemon` flag set, which means
|
that if your main thread exits, worker threads will automatically be
|
killed. If you want to make sure that your ``fn`` runs to completion, then
|
you should make sure that the main thread remains alive until ``deliver``
|
is called.
|
|
It is safe to call this function simultaneously from multiple threads.
|
|
Args:
|
|
fn (sync function): Performs arbitrary blocking work.
|
|
deliver (sync function): Takes the `outcome.Outcome` of ``fn``, and
|
delivers it. *Must not block.*
|
|
Because worker threads are cached and reused for multiple calls, neither
|
function should mutate thread-level state, like `threading.local` objects
|
â or if they do, they should be careful to revert their changes before
|
returning.
|
|
Note:
|
|
The split between ``fn`` and ``deliver`` serves two purposes. First,
|
it's convenient, since most callers need something like this anyway.
|
|
Second, it avoids a small race condition that could cause too many
|
threads to be spawned. Consider a program that wants to run several
|
jobs sequentially on a thread, so the main thread submits a job, waits
|
for it to finish, submits another job, etc. In theory, this program
|
should only need one worker thread. But what could happen is:
|
|
1. Worker thread: First job finishes, and calls ``deliver``.
|
|
2. Main thread: receives notification that the job finished, and calls
|
``start_thread_soon``.
|
|
3. Main thread: sees that no worker threads are marked idle, so spawns
|
a second worker thread.
|
|
4. Original worker thread: marks itself as idle.
|
|
To avoid this, threads mark themselves as idle *before* calling
|
``deliver``.
|
|
Is this potential extra thread a major problem? Maybe not, but it's
|
easy enough to avoid, and we figure that if the user is trying to
|
limit how many threads they're using then it's polite to respect that.
|
|
N)Ú THREAD_CACHEr* )r r r r r r* o s <r* ) Ú threadingr r r Ú itertoolsr r r r r& r+ r* r r r r Ú<module> s #4
|
