Python 同步子类线程

Question

First of all, I'm new to threading in Python and actually pretty new to Python in general, so please excuse if the question is not well asked.

I have 2 modules that each include one class. These classes are both subclasses of threading.Thread . I start these two threads from a third module, main.py :

from controller import Controller
from server import Server
from ultrasonic import Ultrasonic

if __name__ == "__main__":
    controller = Controller()

    server = Server(controller)
    server.start()

    ultrasonic = Ultrasonic(controller)
    ultrasonic.start()

As you can see, both threads access another class in a different module, Controller . To make sure the two threads won't interfere while calling methods of Controller , I want to synchronize these threads. I saw, that there's the option of using threading.Lock , but I'm not sure how to implement this in my specific case, with different subclasses of threading.Thread in different modules.

I hope y'all can help me. Thank you!

EDIT: The methods in the Controller class look like this:

def stop(self):
    GPIO.output(self.LEFT_PIN1, False)
    GPIO.output(self.LEFT_PIN2, False)
    GPIO.output(self.RIGHT_PIN1, False)
    GPIO.output(self.RIGHT_PIN2, False)

I thought it might lead to problems if the GPIO pins recieved contrary signals. If that's not the case, then I don't need to synchronize the threads in the first place.

Answer 1

My guess is that your Controller class could create a Lock :

from Threading import Lock

class Controller:
    lock = Lock()    # class level instance

    def stop(self):
        Controller.lock.acquire()
        GPIO.output(self.LEFT_PIN1, False)
        GPIO.output(self.LEFT_PIN2, False)
        GPIO.output(self.RIGHT_PIN1, False)
        GPIO.output(self.RIGHT_PIN2, False)
        Controller.lock.release()

This way the Controller class creates a single Lock when it is defined.

When any call is make to stop() , the current thread acquires the lock and releases it upon return. Any other thread which makes it to the acquire() call, blocks until the first thread releases it.

Better is to use context management and the with statement:

    def stop(self):
        with Controller.lock:
            GPIO.output(self.LEFT_PIN1, False)
            GPIO.output(self.LEFT_PIN2, False)
            GPIO.output(self.RIGHT_PIN1, False)
            GPIO.output(self.RIGHT_PIN2, False)

Note that I've used a Lock at the class level since you are locking access to the GPIO pins of your processor and there will only be one set of those.