FM / _threads

/usr/lib/python3/dist-packages/twisted/_threads/

/usr/lib/python3/dist-packages/twisted/_threads

Name	Size	Mode	Actions
test/	-	0755	rm
__pycache__/	-	0755	rm
_convenience.py	894	0644	edit dl rm
_ithreads.py	1741	0644	edit dl rm
_memory.py	1593	0644	edit dl rm
_pool.py	2268	0644	edit dl rm
_team.py	7149	0644	edit dl rm
_threadworker.py	3291	0644	edit dl rm
__init__.py	505	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/_threads/_pool.py (2268B)

# -*- test-case-name: twisted._threads.test -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Top level thread pool interface, used to implement
L{twisted.python.threadpool}.
"""

from queue import Queue
from threading import Lock, Thread, local as LocalStorage

from twisted.python.log import err
from ._team import Team
from ._threadworker import LockWorker, ThreadWorker

def pool(currentLimit, threadFactory=Thread):
    """
    Construct a L{Team} that spawns threads as a thread pool, with the given
    limiting function.

@note: Future maintainers: while the public API for the eventual move to
        twisted.threads should look I{something} like this, and while this
        function is necessary to implement the API described by
        L{twisted.python.threadpool}, I am starting to think the idea of a hard
        upper limit on threadpool size is just bad (turning memory performance
        issues into correctness issues well before we run into memory
        pressure), and instead we should build something with reactor
        integration for slowly releasing idle threads when they're not needed
        and I{rate} limiting the creation of new threads rather than just
        hard-capping it.

@param currentLimit: a callable that returns the current limit on the
        number of workers that the returned L{Team} should create; if it
        already has more workers than that value, no new workers will be
        created.
    @type currentLimit: 0-argument callable returning L{int}

@param threadFactory: Factory that, when given a C{target} keyword argument,
        returns a L{threading.Thread} that will run that target.
    @type threadFactory: callable returning a L{threading.Thread}

@return: a new L{Team}.
    """

def startThread(target):
        return threadFactory(target=target).start()

def limitedWorkerCreator():
        stats = team.statistics()
        if stats.busyWorkerCount + stats.idleWorkerCount >= currentLimit():
            return None
        return ThreadWorker(startThread, Queue())

team = Team(
        coordinator=LockWorker(Lock(), LocalStorage()),
        createWorker=limitedWorkerCreator,
        logException=err,
    )
    return team

cmd: