Dieser Artikel bietet Ihnen eine Einführung (Code) über das Concurrent Future-Modul in Python. Ich hoffe, dass er für Freunde hilfreich ist.
concurrent.futures-Modul
Das Hauptmerkmal dieses Moduls sind die Klassen ThreadPoolExecutor und ProcessPoolExecutor. Beide Klassen erben von der Klasse concurrent.futures._base.Executor. Die von ihnen implementierten Schnittstellen können verwendet werden In verschiedenen aufrufbaren Objekten werden sie in Threads oder Prozessen ausgeführt und alle verwalten intern einen Arbeitsthread oder Prozesspool.
Die Klassen ThreadPoolExecutor und ProcessPoolExecutor sind fortgeschrittene Klassen. In den meisten Fällen müssen Sie nur lernen, sie zu verwenden, ohne auf ihre Implementierungsdetails zu achten.
####ProcessPoolExecutor-Klasse
>class ThreadPoolExecutor(concurrent.futures._base.Executor)
>| This is an abstract base class for concrete asynchronous executors.
>| Method resolution order:
>| ThreadPoolExecutor
| concurrent.futures._base.Executor
| builtins.object
|
| Methods defined here:
|
| init(self, max_workers=None, thread_name_prefix='')
| Initializes a new ThreadPoolExecutor instance.
|
| Args:
| max_workers: The maximum number of threads that can be used to
| execute the given calls.
| thread_name_prefix: An optional name prefix to give our threads.
|
| shutdown(self, wait=True)
| Clean-up the resources associated with the Executor.
|
| It is safe to call this method several times. Otherwise, no other
| methods can be called after this one.
|
| Args:
| wait: If True then shutdown will not return until all running
| futures have finished executing and the resources used by the
| executor have been reclaimed.
|
| submit(self, fn, *args, **kwargs)
| Submits a callable to be executed with the given arguments.
|
| Schedules the callable to be executed as fn(*args, **kwargs) and returns
| a Future instance representing the execution of the callable.
|
| Returns:
| A Future representing the given call.
|
| ----------------------------------------------------------------------
| Methods inherited from concurrent.futures._base.Executor:
|
| enter(self)
|
| exit(self, exc_type, exc_val, exc_tb)
|
| map(self, fn, *iterables, timeout=None, chunksize=1)
| Returns an iterator equivalent to map(fn, iter).
|
| Args:
| fn: A callable that will take as many arguments as there are
| passed iterables.
| timeout: The maximum number of seconds to wait. If None, then there
| is no limit on the wait time.
| chunksize: The size of the chunks the iterable will be broken into
| before being passed to a child process. This argument is only
| used by ProcessPoolExecutor; it is ignored by
| ThreadPoolExecutor.
|
| Returns:
| An iterator equivalent to: map(func, *iterables) but the calls may
| be evaluated out-of-order.
|
| Raises:
| TimeoutError: If the entire result iterator could not be generated
| before the given timeout.
| Exception: If fn(*args) raises for any values.
Nach dem Login kopieren
Die Initialisierung kann eine maximale Anzahl von Prozessen als Wert ihres Parameters max_workers angeben. Standardmäßig ist die Zahl angegeben der Kerne der aktuell laufenden Maschine, die von os.cpu_count() abgerufen werden können; die Klasse enthält Methoden:
map()-Methode, die eine ähnliche Funktion wie Pythons integrierte Methode hat. in der Methode map(), also Mapping, und die Parameter sind:
Eine aufrufbare Funktion fn
Ein Iterator iteriert
Timeout Timeout
chunksize Wenn es größer als 1 ist, wird der Iterator in Chunks verarbeitet
---->> Diese Funktion hat folgende Eigenschaften: Das Rückgabeergebnis stimmt mit der Reihenfolge überein, in der der Anruf gestartet wird. Dies bedeutet, dass die Ausführung nicht blockiert wird der letztere kann beendet sein, bevor der erstere aufgerufen wird.
Wenn Sie vor der Verarbeitung alle Ergebnisse erhalten müssen, können Sie die Methode „submit()“ in Kombination mit der Funktion „futures.as_completed“ verwenden.
shutdown()-Methode, bereinigt alle Ressourcen im Zusammenhang mit dem aktuellen Executor (Executor)
submit()-Methode, sendet ein aufrufbares The Objekt verwendet fn
erbt die Methoden __enter__() und __exit__() von concurrent.futures._base.Executor, was bedeutet, dass ProcessPoolExecutor-Objekte in with-Anweisungen verwendet werden können.
from concurrent import futures
with futures.ProcessPoolExecutor(max_works=3) as executor:
executor.map()
Nach dem Login kopieren
ThreadPoolExecutor-Klasse
class ThreadPoolExecutor(concurrent.futures._base.Executor)
| This is an abstract base class for concrete asynchronous executors.
|
| Method resolution order:
| ThreadPoolExecutor
| concurrent.futures._base.Executor
| builtins.object
|
| Methods defined here:
|
| init(self, max_workers=None, thread_name_prefix='')
| Initializes a new ThreadPoolExecutor instance.
|
| Args:
| max_workers: The maximum number of threads that can be used to
| execute the given calls.
| thread_name_prefix: An optional name prefix to give our threads.
|
| shutdown(self, wait=True)
| Clean-up the resources associated with the Executor.
|
| It is safe to call this method several times. Otherwise, no other
| methods can be called after this one.
|
| Args:
| wait: If True then shutdown will not return until all running
| futures have finished executing and the resources used by the
| executor have been reclaimed.
|
| submit(self, fn, *args, **kwargs)
| Submits a callable to be executed with the given arguments.
|
| Schedules the callable to be executed as fn(*args, **kwargs) and returns
| a Future instance representing the execution of the callable.
|
| Returns:
| A Future representing the given call.
|
| ----------------------------------------------------------------------
| Methods inherited from concurrent.futures._base.Executor:
|
| enter(self)
|
| exit(self, exc_type, exc_val, exc_tb)
|
| map(self, fn, *iterables, timeout=None, chunksize=1)
| Returns an iterator equivalent to map(fn, iter).
|
| Args:
| fn: A callable that will take as many arguments as there are
| passed iterables.
| timeout: The maximum number of seconds to wait. If None, then there
| is no limit on the wait time.
| chunksize: The size of the chunks the iterable will be broken into
| before being passed to a child process. This argument is only
| used by ProcessPoolExecutor; it is ignored by
| ThreadPoolExecutor.
|
| Returns:
| An iterator equivalent to: map(func, *iterables) but the calls may
| be evaluated out-of-order.
|
| Raises:
| TimeoutError: If the entire result iterator could not be generated
| before the given timeout.
| Exception: If fn(*args) raises for any values.
Nach dem Login kopieren
ist der ProcessPoolExecutor-Klasse sehr ähnlich, außer dass es sich bei einer um einen Verarbeitungsprozess und bei der anderen um einen Verarbeitungsthread handelt, der entsprechend ausgewählt werden kann auf tatsächliche Bedürfnisse.
Beispiel
from time import sleep, strftime
from concurrent import futures
def display(*args):
print(strftime('[%H:%M:%S]'), end="")
print(*args)
def loiter(n):
msg = '{}loiter({}): doing nothing for {}s'
display(msg.format('\t'*n, n, n))
sleep(n)
msg = '{}loiter({}): done.'
display(msg.format('\t'*n, n))
return n*10
def main():
display('Script starting')
executor = futures.ThreadPoolExecutor(max_workers=3)
results = executor.map(loiter, range(5))
display('results:', results)
display('Waiting for inpidual results:')
for i, result in enumerate(results):
display('result {} : {}'.format(i, result))
if __name__ == '__main__':
main()Nach dem Login kopieren
Laufergebnisse:
[20:32:12]Script starting
[20:32:12]loiter(0): doing nothing for 0s
[20:32:12]loiter(0): done.
[20:32:12] loiter(1): doing nothing for 1s
[20:32:12] loiter(2): doing nothing for 2s
[20:32:12]results: <generator object Executor.map.<locals>.result_iterator at 0x00000246DB21BC50>
[20:32:12]Waiting for inpidual results:
[20:32:12] loiter(3): doing nothing for 3s
[20:32:12]result 0 : 0
[20:32:13] loiter(1): done.
[20:32:13] loiter(4): doing nothing for 4s
[20:32:13]result 1 : 10
[20:32:14] loiter(2): done.
[20:32:14]result 2 : 20
[20:32:15] loiter(3): done.
[20:32:15]result 3 : 30
[20:32:17] loiter(4): done.
[20:32:17]result 4 : 40
Nach dem Login kopieren
Die Laufergebnisse können auf verschiedenen Maschinen unterschiedlich sein.
Im Beispiel ist max_workers=3 festgelegt. Sobald der Code ausgeführt wird, werden nach drei Sekunden drei Objekte (0, 1, 2) mit der Operation loiter() ausgeführt Objekt 0 endet und das Ergebnis ist Ergebnis 0. Danach beginnt die Ausführung von Objekt 4. In ähnlicher Weise endet die Ausführungszeit von Objekt 4 nach dem Drucken von Ergebnis 1, dem Ausführungsergebnis von Objekt 1.
Das obige ist der detaillierte Inhalt vonEinführung in das Concurrent Future-Modul in Python (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
