子进程完成后停止Python脚本

Question

When running my script, I am running a set of for loops dynamically. Basically calling a list of items, checking to see what 'stage' that item needs to be ran in, and then running them all in that order. When I am trying to run these loops, it gets through the first object, and then gives a "[1]+ Stopped Script.py" in the terminal. I have found ways to start back up my script, but no post about how to avoid this happening entirely.

I have tried using Popen , call , check_output , etc. They all get the same result. I am sure it is the other item I am calling that is doing this at the end of it, but I do not think that another program closing out should kill my script, especially not in a subprocess.

I have also tried using threading and multiprocessing. Both to no avail.

def foo(list):
    stages = 0
    for c in things:
        info = load_json_info(c)
        if info["stage"] >= stages:
            stages = info["stage"]
    for p in list:
        use_list(p)
    stages = stages + 1
    for i in range(stages):
        for b in list:
            info = load_json_info(b)
            if info["stage"] == i:
                if info["check"] != "NO":
                    output = call("command", shell=True)
                    if output == 0:
                        DO_THING()
                    else:
                        DONT_DO_THING()
                else:
                    DONT_DO_THING()

It gets to the DO_THING() and goes through all of that, then when it comes time to call another subprocess it dies out again. Whether that subprocess lives in DO_THING() or I comment everything out and just get it to hit the output = call("command", shell=True) line again. As soon as it goes to use subprocess again it stops.

Any suggestions or ways people have found to block whatever is being passed to stop my script?

(Just as a heads up, I do not have access to the source of the "command" that is causing my script to stop, and the "command" I am using is not important since I can not do anything on that end. I must use this "command" as well.)

Answer 1

The message you see indicates that your subprocess is being stopped , not that there is an error. This happens for example when typing Ctrl-Z after starting a process in the shell, or equivalently, sending the target process the SIGTSTP signal using the kill command. Presumably, the command to which you don't have access is receiving this signal. It could even be sending it to itself, although without knowing more about the command it's just speculation as to how or why that's happening.

You can choose to ignore this signal in Python by using the signal module, specifically the pthread_sigmask() function. One specifies a mask of signals, and what to do about them. In this case, you want to ignore the SIGTSTP signal, which an be done with: signal.pthread_sigmask(signal.SIG_BLOCK, (signal.SIGTSTP,)) . (The latter argument is actually a sequence of signals to ignore.)

Running this snippet of code, you should see that you can type Ctrl-Z in the terminal, and the shell should show [1]+ Stopped ... :

import time
duration = 5.0
print('Sleeping for {:0.2f} seconds'.format(duration))
time.sleep(duration)

However, using the following code, one will see that the signal is ignored, and the process will continue to "work" (sleep, in this case) regardless of the signal. You should just see ^Z at the shell whenever you press Ctrl-Z .

import time
import signal
duration = 5.0
print('Sleeping for {:0.2f} seconds, ignoring SIGTSTP'.format(duration))
signal.pthread_sigmask(signal.SIG_BLOCK, (signal.SIGTSTP,))
time.sleep(duration)

To actually use this in your script, ignore the signal before you call the relevant command . It is good practice to query a process's signal mask beforehand, and reset it to that value after you're done with command . You should look at the man pages for signal(3) , sigprocmask(2) , and kill(2) for more information about signals and processes.

Edit for Python <= 2.7

signal.pthread_sigmask was added in Python 3.3. A solution that should work for earlier versions is to directly ignore the signal, by installing a handler which does just that. For example:

import signal
import time

duration = 5.0
signal.signal(signal.SIGTSTP, signal.SIG_IGN)
print 'Sleeping for %f seconds, ignoring SIGTSTP' % duration
time.sleep(duration)

As with the 3.3 example above, you should just see ^Z if you hit Ctrl-Z , indicating that the signal was ignored.