Unix Runtime Behavior

Install a SIGALRM handler with signal.signal that raises an exception, call signal.alarm(seconds) just before the blocking call, and call signal.alarm(0) in a finally block. The handler's exception unwinds the blocked call.

CPython installs its own default handler for signal.SIGINT that raises KeyboardInterrupt in the main thread, so finally blocks and atexit hooks still run. signal.SIGTERM keeps the operating system default, which terminates the process immediately with no Python cleanup.

Since Python 3.5, the interpreter reissues a system call that a signal interrupted instead of raising InterruptedError, after running the Python-level handler and recomputing any remaining timeout. Hand-written EINTR retry loops around stdlib calls became dead code.

CPython installs its own C handler, which only records that the signal is pending. Your Python function runs later, when the main thread of the main interpreter reaches its next bytecode boundary check.

The kernel gives PID 1 no default action: a signal left at its default disposition is discarded, not acted on. CPython installs a handler for SIGINT but not SIGTERM, so call signal.signal(signal.SIGTERM, handler) yourself.

Pass check=True to subprocess.run, or call check_returncode() on the CompletedProcess it returns. Both raise subprocess.CalledProcessError, whose returncode attribute holds the child's exit status. Without check, a non-zero status comes back silently and is easy to ignore.

Popen.terminate() sends SIGTERM, which the child may catch and use to shut down cleanly. Popen.kill() sends SIGKILL, which no process can catch, block or ignore, so the child dies immediately with no cleanup. Both signal only the direct child.

A kernel pipe holds a fixed amount, roughly 64 KiB on Linux. Once the child fills it, the child blocks in write() while the parent blocks in Popen.wait, so neither moves. Popen.communicate drains both pipes and waits in one call.

It replaces it. The mapping you pass becomes the child's entire environment, so anything you leave out - PATH, HOME, LANG - is simply not there. Merge on purpose with a dict such as {**os.environ, 'KEY': 'value'}.

With shell=True the direct child is /bin/sh, so Popen.pid is the shell's pid and terminate() signals the shell, not the program it started. Start the child with start_new_session=True and signal the whole group with os.killpg(os.getpgid(p.pid), signal.SIGTERM).

Because CPython writes an object's reference count whenever a reference to it is taken or dropped. Merely reading a shared object dirties the whole page holding it, so a worker's private memory grows until little is really shared.

sys.exit() only raises SystemExit, so the child unwinds, runs the parent's inherited atexit callbacks and flushes inherited buffers -- cleanup that happens twice. os._exit() ends the process immediately, skipping all of it.

Because the child gets the parent's whole memory but only the forking thread, so any lock the vanished threads held stays locked forever and the child deadlocks. Python 3.12 added the warning; Python 3.14 moved multiprocessing's Unix default to forkserver.

No. os.fork() gives the child a copy-on-write copy of the parent's address space, so the child sees the parent's objects exactly as they were at fork time, but every write it makes stays private to it.

os.fork() copies the whole process, including text still sitting in stdout's userspace buffer. Both copies flush that same pending text later, so it prints twice. Call sys.stdout.flush() immediately before forking.

A file object holds a kernel descriptor until something closes it. CPython usually closes it when the last reference disappears, but that is a refcounting implementation detail. A with block closes deterministically, even when the body raises.

os.cpu_count() reports the logical processors the host kernel exposes. A container's CPU limit is enforced as scheduling bandwidth rather than by hiding processors, so the count still says 64 on a two-CPU budget.

MemoryError is raised only when an allocation request fails immediately, so the interpreter regains control. A cgroup limit is charged when pages are touched, not when they are requested, so the kernel kills the process instead -- there is nothing to catch.

A process may move its soft limit freely between zero and its hard limit, so those changes are reversible. Lowering the hard limit is one-way: raising it again needs privilege an ordinary process lacks, and the drop is inherited by children.

Status 137 is 128 + 9: the kernel delivered SIGKILL, most often when the process crossed its container memory limit. SIGKILL cannot be caught, so no except, finally or atexit code runs and nothing is printed.

Because one CPython process executes Python bytecode on one core at a time under the global interpreter lock. Forking several workers, each with its own interpreter and its own lock, puts real work on every core and isolates a crash.

Copy-on-write shares pages only until something writes to one. CPython stores a reference count inside every object header, so merely touching a preloaded object dirties its page and the sharing quietly decays over the worker's lifetime.

Open a fixed lockfile with os.open, then call fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB). A BlockingIOError means another copy holds it, so exit. Keep the descriptor open for the whole run; the kernel releases the lock when the process dies.

A supervisor manages a process by being its parent. Staying in the foreground keeps the supervisor as the parent, so it knows the pid, reads the exit status, and captures whatever the process writes to sys.stdout and sys.stderr.

A pre-fork worker holds one request and costs a whole interpreter. A thread holds one request and costs a stack. An async worker holds thousands of waiting connections in one thread — but only while nothing blocks.

CPython picks buffering per stream at startup: a terminal gets line buffering, so every newline flushes; a pipe or file gets a block buffer, 128 KiB on Python 3.14, that waits until it fills.

CPython sets SIGPIPE to signal.SIG_IGN while the interpreter starts up. With the signal ignored, the failing write returns errno.EPIPE to the caller instead of terminating the process, and Python raises BrokenPipeError so the code can react.

Both force stdout and stderr to be unbuffered: the binary layer under each stream is created without a buffer and the text layer is write-through, so every write reaches the descriptor at once. Neither affects stdin.

contextlib.redirect_stdout only rebinds the Python object sys.stdout. Compiled code writes straight to file descriptor 1 and never consults sys.stdout, so its output bypasses the capture; redirecting the descriptor itself with os.dup2 is what catches it.

BrokenPipeError says a write failed because nobody is reading the other end any more: the downstream process exited or closed its read descriptor. The kernel fails the write with errno.EPIPE (32) and Python turns that into this OSError subclass.