Résumé de l'exemple de code de traitement parallèle / parallèle Python

Je vais vous montrer comment faire deux ou plusieurs processus en même temps avec Python

--Fil

• Pool de discussion
• Pool de processus
• Boucle d'événement (coroutine)

Filetage

Les threads vous permettent d'exécuter plusieurs fonctions en même temps. Cela fonctionne si vous passez la fonction en tant que cible à la classe threading.Thread et la démarrez avecstart ().

import time
import threading


def func1():
    while True:
        print("func1")
        time.sleep(1)


def func2():
    while True:
        print("func2")
        time.sleep(1)


if __name__ == "__main__":
    thread_1 = threading.Thread(target=func1)
    thread_2 = threading.Thread(target=func2)

    thread_1.start()
    thread_2.start()

Résultat d'exécution

func1
func2
func2
func1
func1
func2
func2
func1

Pool de threads (concurrent.futures)

Il est encore plus puissant si vous utilisez le package concurrent.futures de Python 3.2 ou version ultérieure. Utilisez la classe ThreadPoolExecutor.

Si vous décidez du nombre maximum de max_workers à exécuter en même temps en premier, il utilisera à nouveau les threads, donc il est plus intelligent que les threads ordinaires présentés ci-dessus. Si vous disposez d'une version plus récente de Python, vous pouvez l'utiliser activement.

import time
import concurrent.futures


def func1():
    while True:
        print("func1")
        time.sleep(1)


def func2():
    while True:
        print("func2")
        time.sleep(1)


if __name__ == "__main__":
    executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
    executor.submit(func1)
    executor.submit(func2)

Résultat d'exécution

func1
func2
func1
func2
func1
func2
func1
func2

Pool de processus (concurrent.futures)

Le même package concurrent.futures ci-dessus, mais il est appelé ** processus pool ** au lieu de thread pool. Il y a aussi.

En divisant en unités de processus au lieu de threads, vous ne serez pas soumis aux restrictions de Global Interpreter Lock (GIL) ** Vous pourrez fonctionner avec plusieurs cœurs. ** ** Toutefois, étant donné qu'il utilise un processus plus volumineux que le thread, d'autres restrictions peuvent augmenter. Mise en garde!

C'est facile à utiliser, il suffit de changer le ThreadPoolExecutor présenté ci-dessus en ProcessPoolExecutor.

import time
import concurrent.futures


def func1():
    while True:
        print("func1")
        time.sleep(1)


def func2():
    while True:
        print("func2")
        time.sleep(1)


if __name__ == "__main__":
    executor = concurrent.futures.ProcessPoolExecutor(max_workers=2)
    executor.submit(func1)
    executor.submit(func2)

Résultat d'exécution

func1
func2
func1
func2
func1
func2
func1
func2

Boucle d'événement (coroutine)

Il existe également un moyen d'exécuter plusieurs processus dans un seul thread. L'un d'eux est la ** boucle d'événements **. En Python3.4 ou supérieur, il peut être réalisé avec module asyncio.

Il est facile de comprendre la différence avec le multi-threading et quand l'utiliser ... en lisant Traitement asynchrone en Python: référence de recherche inversée asyncio. ..

C'est beaucoup plus efficace que d'augmenter les threads pour les E / S asynchrones telles que la communication et les entrées / sorties de fichiers, mais il est difficile de s'y habituer car le concept est difficile.

L'exemple de code est assez différent du cas de thread.

J'utilise ʻasyncio.sleepau lieu detime.sleep pour attendre, car j'appelle ʻasyncio.sleep et passe à un autre processus parallèle en attendant. C'est juste un collout.

import asyncio


@asyncio.coroutine
def func1():
    while True:
        print("func1")
        yield from asyncio.sleep(1)


@asyncio.coroutine
def func2():
    while True:
        print("func2")
        yield from asyncio.sleep(1)


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    tasks = asyncio.wait([func1(), func2()])
    loop.run_until_complete(tasks)

Résultat d'exécution

func2
func1
func2
func1
func2
func1
func2
func1