Exécute une boucle infinie à l'aide de threads en python

Mon programme est conçu de la manière suivante:

Première partie du programme prend des valeurs en temps réel à partir d'un capteur et de parcelles à l'aide de Matplotlib. Ce qui doit être fait pour de longues durées. Et aussi, il enregistre des informations dans une base de données.
La deuxième partie est l'adresse IP de la Caméra. Je dois obtenir l'entrée à partir d'une Caméra IP et les afficher. Pour l'affichage, je suis en utilisant OpenCV est imshow méthode. Aussi, je suis de stocker la vidéo de la Caméra IP.

Question: j'ai les algorithmes en place, le problème est que j'ai besoin d'exécuter à la fois dans un while. La condition est que je ne suis pas sortie de l'un d'eux. Maintenant threading est une bonne alternative pour cela, mais j'ai lu sur la GIL, alors comment puis-je aller sur l'exécution de deux boucles infinies?

from multiprocessing import Process

def methodA():
    while TRUE:
        do something

def methodB():
    while TRUE:
        do something

p=Process(target=methodA())
p.start()
p1=Process(target=methodB())
p1.start()

Maintenant, quand je démarre le processus de p il commence à s'exécuter, après comment puis-je commencer à p1 à exécuter simultanément?

Si votre seul souci est en cours d'exécution de boucle infinie, il n'y a pas de réel problème à l'utilisation du multithreading.
Qu'en est GIL?
Aussi, une fois que j'ai lancer l'exécution d'un thread, comment puis-je exécuter l'autre thread lorsque le premier thread est en cours d'exécution en continu/à l'infini?
Je ne comprends pas ce que tu veux dire. Il existe deux types de threads s'exécutant en parallèle. À moins que l'un dépend de l'autre, vous n'avez pas de réel problème.
Une méthode s'exécute à l'infini, je le commence dans un thread, maintenant comment puis-je exécuter un autre thread?. Attendez, je vais ajouter un peu de code pour faire la lumière sur le problème.

OriginalL'auteur Prakhar Mohan Srivastava | 2014-04-16

25

Que j'ai compris votre question, vous avez deux différentes tâches que vous souhaitez effectuer en continu. Maintenant en ce qui concerne vos questions:

comment puis-je aller sur l'exécution de deux boucles infinies?

Vous pouvez créer deux threads différents qui va exécuter ces boucles infinies pour vous. Le premier thread qui va effectuer votre task1 et la seconde pour effectuer task2.

Aussi, une fois que j'ai lancer l'exécution d'un thread, comment puis-je exécuter l'autre
fil de discussion lorsque le premier thread est en cours d'exécution en continu/à l'infini?

Si vous utilisez deux threads différents, alors vous n'avez pas besoin d'être inquiet au sujet de cette question. Si les fils ne sont pas le partage de toute ressource, alors vous n'avez pas besoin de s'inquiéter à propos de ce fait.
Comment jamais, si vous voulez arrêter/mettre en pause un fil de l'autre thread, ou vice versa, alors vous pouvez mettre en œuvre un mécanisme à l'aide de drapeaux ou des serrures. Ces questions vous aideront dans ce cas:

Est-il possible de tuer un Thread en Python?

Pourquoi le python threading.Objet Thread a "démarrer", mais pas "stop"?

faire-un-programme-munltithreaded

Exemple d'échantillon à l'aide de filetage:
```
from threading import Thread

class myClassA(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()
    def run(self):
        while True:
            print 'A'

class myClassB(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()
    def run(self):
        while True:
            print 'B'


myClassA()
myClassB()
while True:
    pass
```
De ressources partagées?

Utilisation Les verrous pour eux. Voici quelques exemples. Un, deux et Comment synchroniser les threads en python?

que faire si je ne veux pas l'exécuter à l'aide de classes? Comment puis-je faire cela en utilisant uniquement des méthodes?
```
from threading import Thread

def runA():
    while True:
        print 'A\n'

def runB():
    while True:
        print 'B\n'

if __name__ == "__main__":
    t1 = Thread(target = runA)
    t2 = Thread(target = runB)
    t1.setDaemon(True)
    t2.setDaemon(True)
    t1.start()
    t2.start()
    while True:
        pass
```
Veuillez vérifier la mise à jour de question si vous ne l'avez pas fait, il va vous expliquer la situation plus clairement.
Et que dois-je faire si elles partagent des ressources?
Wow! Merci pour la réponse. J'ai essayé et cela fonctionne parfaitement! Juste quelques questions, pourquoi êtes-vous en passant Thread la classe? Et si je ne veux pas l'exécuter à l'aide de classes? Comment puis-je faire cela en utilisant uniquement des méthodes?
De réponses mis à jour

OriginalL'auteur ρss

    from threading import Thread
import time

class PrintA(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.running = True

    def run(self):
        while self.running:
            print('A')
            time.sleep(1)
    def stop(self):
        self.running = False

class PrintB(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.running = True
    def run(self):
        while self.running:
            print('B')
            time.sleep(2)
    def stop(self):
        self.running = False

a = PrintA()
b = PrintB()

a.start()
b.start()

time.sleep(10)
a.stop()
time.sleep(10)
b.stop()

OriginalL'auteur CLESIO MAXUEL BARBOZA DE SOUZA

Vous devez vous connecter pour publier un commentaire.