11 releases (2 stable)
1.0.1 | Aug 1, 2024 |
---|---|
1.0.0 | Nov 16, 2021 |
0.3.5 | Mar 15, 2021 |
0.3.4 | Sep 7, 2019 |
0.2.1 | Feb 12, 2017 |
#41 in Operating systems
591,658 downloads per month
Used in 398 crates
(20 directly)
29KB
361 lines
shared_child.rs
A library for awaiting and killing child processes from multiple threads.
The
std::process::Child
type in the standard library provides
wait
and
kill
methods that take &mut self
, making it impossible to kill a child process
while another thread is waiting on it. That design works around a race
condition in Unix's waitpid
function, where a PID might get reused as soon
as the wait returns, so a signal sent around the same time could
accidentally get delivered to the wrong process.
However with the newer POSIX waitid
function, we can wait on a child
without freeing its PID for reuse. That makes it safe to send signals
concurrently. Windows has actually always supported this, by preventing PID
reuse while there are still open handles to a child process. This library
wraps std::process::Child
for concurrent use, backed by these APIs.
Compatibility note: The libc
crate doesn't currently support waitid
on
NetBSD or OpenBSD, or on older versions of OSX. There might also
be some version of OSX where the
waitid
function exists but is broken. We can add a "best effort"
workaround using waitpid
for these platforms as we run into them. Please
file an issue if
you hit this.
Example
use shared_child::SharedChild;
use std::process::Command;
use std::sync::Arc;
// Spawn a child that will just sleep for a long time,
// and put it in an Arc to share between threads.
let mut command = Command::new("python");
command.arg("-c").arg("import time; time.sleep(1000000000)");
let shared_child = SharedChild::spawn(&mut command).unwrap();
let child_arc = Arc::new(shared_child);
// On another thread, wait on the child process.
let child_arc_clone = child_arc.clone();
let thread = std::thread::spawn(move || {
child_arc_clone.wait().unwrap()
});
// While the other thread is waiting, kill the child process.
// This wouldn't be possible with e.g. Arc<Mutex<Child>> from
// the standard library, because the waiting thread would be
// holding the mutex.
child_arc.kill().unwrap();
// Join the waiting thread and get the exit status.
let exit_status = thread.join().unwrap();
assert!(!exit_status.success());
Dependencies
~0–8MB
~62K SLoC