Python线程执行阻止了其他线程

Question

Both threads work if accessed but when they are executed together halt_listener will monopolize the resources not allowing import_1 to execute. The end goal is to have halt_listener listen for a kill message and then set a run variable to false. This has worked when I was sending a pipe to the halt_listener but I prefer a queue.

Here is my code:

import multiprocessing 
import time 
from threading import Thread

class test_imports:#Test classes remove 
      alive = {'import_1': True, 'import_2': True};

      def halt_listener(self, control_Queue, thread_Name, kill_command):
          while True:
              print ("Checking queue for kill")
              isAlive = control_queue.get()
              print ("isAlive", isAlive)
              if isAlive == kill_command:
                 print ("kill listener triggered")
                 self.alive[thread_Name] = False;
                 return

      def import_1(self, control_Queue, thread_Number):
          print ("Import_1 number %d started") % thread_Number
          halt = test_imports()
          t = Thread(target=halt.halt_listener, args=(control_Queue, 'import_1', 't1kill'))
          count = 0 
          t.run()
          global alive 
          run = test_imports.alive['import_1'];
          while run:
                print ("Thread type 1 number %d run count %d") % (thread_Number, count)
                count = count + 1
                print ("Test Import_1 ", run)
                run = self.alive['import_1'];
          print ("Killing thread type 1 number %d") % thread_Number 

Am I missing something?

Answer 1

The problem is that you're calling t.run() . run isn't a method that starts a thread; run is the actual code that's meant to run on the thread. By calling it directly, you're running it on your thread, and waiting for it to finish.

What you want is t.start() .

See the documentation on threading.Thread for details.

---

While we're at it, there are a few other problems with your code.

First, you don't have a lock around self.alive . You can't change a value (except for a small number of automatically-self-synchronized types like Queue ) in one thread and access it in another without a lock. You will often get away with it, but "often" in a multithreaded program just means it won't fail until your big demonstration, and it will then take weeks to figure out how to reproduce before you can even begin fixing it… (In this case, a Condition might make more sense than a Lock, but either way, you need to synchronize on something .)

Meanwhile, looping as fast as possible to poll self.alive['import_1'] is going to burn 100% CPU for no good reason. There's almost always a better way to wait on something (eg, in this case, if you used a Condition for synchronization, you could also use it for waiting here); in the rare cases when there isn't, you should at least sleep every time through the loop.

alive is actually a class attribute rather than an instance attribute. That's usually not what you want. In fact, you try to access both test_imports.alive and self.alive , but both of those will end up being the class attribute as long as you never assign to it, which makes it more confusing. And then, on top of that, you have a global with the same name, which is just a recipe for extreme confusion.

Also, this looks like Python 2 code, but you're using print as if it were a function in some cases—eg, print ("isAlive", isAlive) . This isn't going to do what you want—instead of printing something like isAlive command , it's going to print something like ('isAlive', 'command') , which is not very pretty. And meanwhile, the extra parentheses in expressions like ("Import_1 number %d started") % thread_Number mean that someone has to read that over a few times to convince themselves that the parentheses aren't actually doing anything.

Finally, why are you creating a separate test_imports instance to call halt_listener on? Clearly the two methods are trying to communicate through attributes on self , but they're not going to do that if they're called on two different objects. Why not just target=self.half_listener ?