it-swarm.com.de

Unendliche Schleifen mit Threads in Python ausführen

Mein Programm ist folgendermaßen aufgebaut:

  1. Der erste Teil des Programms nimmt Echtzeitwerte von einem Sensor und zeichnet sie mit Matplotlib auf. Dies muss für längere Zeit gemacht werden. Außerdem werden Informationen in einer Datenbank protokolliert.
  2. Der zweite Teil ist die IP-Kamera. Ich muss die Eingabe von einer IP-Kamera erhalten und anzeigen. Zur Anzeige verwende ich die imshow-Methode von OpenCV. Ich speichere auch das Video von der IP-Kamera.

Frage: Ich habe die Algorithmen installiert, das Problem ist, dass ich beide in einer while-Schleife ausführen muss. Die Bedingung ist, dass ich keinen von ihnen verlassen kann. Jetzt ist Threading eine gute Alternative, aber ich habe etwas über die GIL gelesen. Wie kann ich also zwei Endlosschleifen ausführen?

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()

Wenn ich nun den Prozess p starte, wird er ausgeführt. Wie starte ich, dass p1 gleichzeitig ausgeführt wird?

Soweit ich Ihre Frage verstanden habe, haben Sie zwei verschiedene Aufgaben, die Sie kontinuierlich ausführen sollen. Nun zu Ihren Fragen:

Wie gehe ich vor, um zwei Endlosschleifen auszuführen?

Sie können zwei verschiedene Threads erstellen, die diese Endlosschleifen für Sie ausführen. Der erste Thread führt Ihre Aufgabe1 und der zweite Thread Aufgabe2 aus. 

Auch wenn ich mit der Ausführung eines Threads beginne, wie führe ich den anderen Thread aus, wenn der erste Thread kontinuierlich/unendlich läuft?

Wenn Sie zwei verschiedene Threads verwenden, müssen Sie sich keine Sorgen um dieses Problem machen. Wenn die Threads keine Ressource gemeinsam nutzen, müssen Sie sich keine Gedanken darüber machen. Wenn Sie jedoch einen Thread aus dem anderen Thread stoppen oder anhalten möchten, können Sie einen Mechanismus mit implementieren Fahnen oder Schlösser. Diese Fragen helfen in diesem Fall:

Gibt es eine Möglichkeit, einen Thread in Python zu töten?

Warum hat das Python-Threading.Thread-Objekt 'start', aber nicht 'stop'?

Making-a-program-munltithreaded

Beispielbeispiel mit Threading:

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

Für gemeinsam genutzte Ressourcen?

Verwenden Sie Locks für sie. Hier sind einige Beispiele. Eins , zwei und Wie synchronisiere ich Threads in Python?

was ist, wenn ich es nicht mit Klassen ausführen möchte? Wie mache ich das nur mit Methoden?

from threading import Thread

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

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

if __== "__main__":
    t1 = Thread(target = runA)
    t2 = Thread(target = runB)
    t1.setDaemon(True)
    t2.setDaemon(True)
    t1.start()
    t2.start()
    while True:
        pass
26
ρ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()