使用python在两个线程之间等待

Question

Need to know whether I can hold a thread for sometime to proceed a action and resume the thread.

for example:

Thread1 having some action to perform and similar like Thread2 is having some action to perform and starting the both threads.

if Thread1 fails in Some point I need to pause the Thread2 and proceed the action to perform, If the action says true it should resume the Thread2 and runs the code where it left..

your answers are welcome!!

Answer 1

You cannot pause a thread that does not co-operate. You may be able to add some co-operation, though. If your thread is a loop, you might be able to emulate a stop signal with a lock:

foo = threading.Lock()

def thread1():
    while True:
        with foo:
            ... do whatever the thread does...


def thread2():
    while True:
        try:
            do whatevet the thread does
        except MyHorribleException:
            with foo:
                ... do remedial actions with thread1 "paused"...

The caveat of this is that if thread1 holds the lock for a long time, thread2 blocks in exception handling until the lock becomes available. Depending on your program logic, this could create a deadlock (thread1 reserving the lock, unable to proceed, waiting for thread2 to fix things but thread2 cannot get the lock as thread1 is holding it).

However, this will guarantee that whenever "remedial actions" are taken, thread1 is not processing data. This might be enough if you have fast processing loops in your threads and thread2 is not needed to fix an ongoing issue with thread1 iteration.

If this is not suitable, then it might be better to use multiprocessing, at least on unix platforms. If you do not create a thread but a subprocess, then you can send it a STOP signal stopping it on its tracks, and when you are ready to proceed, you will send it CONT. If you are using Windows, this will probably not work.

You might also want to consider redesigning your program logic. Generally threads are suitable for independent processing. If two threads need to do things in tandem, stopping and continuing each other, it might be better to interleave these threads into one.