Processes & exec

Running an external program

Go shells out through os/exec. The simplest forms capture output:

// Output(): run to completion, return stdout as []byte.
out, err := exec.Command("git", "rev-parse", "HEAD").Output()
if err != nil {
	// *exec.ExitError carries the non-zero exit + stderr
	log.Fatalf("git failed: %v", err)
}
fmt.Printf("commit: %s", out)

// CombinedOutput(): stdout + stderr together (handy for diagnostics).
out, _ = exec.Command("go", "version").CombinedOutput()

The three ways to launch, by how much control you want:

graph TD
C["exec.Command(name, args...)"] --> R["Run() = Start + Wait<br/>(block until done)"]
C --> S["Start()<br/>(returns now; Wait() later)"]
C --> O["Output()/CombinedOutput()<br/>(run, return captured bytes)"]

Wiring streams, environment, and working dir

A *exec.Cmd is a struct you configure before launching — redirect its streams to any io.Writer/io.Reader, set its environment and directory:

cmd := exec.Command("my-tool", "--flag", userInput) // args are safe, see below
cmd.Stdin = strings.NewReader("data on stdin")
cmd.Stdout = os.Stdout                 // inherit our stdout
cmd.Stderr = os.Stderr
cmd.Dir = "/work"                      // run in this directory
cmd.Env = append(os.Environ(), "LANG=C") // tweak the child's environment

if err := cmd.Run(); err != nil { /* ... */ }
fmt.Println("child pid was:", cmd.ProcessState.Pid())

For long-running commands, stream instead of buffering:

cmd := exec.Command("tail", "-f", "app.log")
stdout, _ := cmd.StdoutPipe()
cmd.Start()
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {        // process each line as it arrives
	fmt.Println("log:", scanner.Text())
}
cmd.Wait()

Timeouts and cancellation

Never run an external command without a leash. CommandContext kills the child when the context is cancelled or times out:

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

cmd := exec.CommandContext(ctx, "slow-converter", "in.mov", "out.mp4")
if err := cmd.Run(); err != nil {
	if ctx.Err() == context.DeadlineExceeded {
		log.Println("converter timed out and was killed")
	}
}

Inspecting the current process

You can’t spawn programs on the playground, but you can introspect the running process — its PID, parent, environment, and arguments. This runs anywhere:

package main

import (
"fmt"
"os"
"strings"
)

func main() {
fmt.Println("pid:        ", os.Getpid())
fmt.Println("parent pid: ", os.Getppid())
fmt.Println("args:       ", os.Args)

// The environment is inherited from the parent and handed to children.
for _, kv := range os.Environ() {
	if strings.HasPrefix(kv, "PATH=") {
		fmt.Println("PATH is set, length:", len(kv))
		break
	}
}

// os.Executable() is the path to this running binary.
if exe, err := os.Executable(); err == nil {
	fmt.Println("executable: ", exe)
}
}

When you Start a child, it inherits this process’s environment by default; set cmd.Env to change that. The child’s PID lives in cmd.Process.Pid once started.

Under the hood: fork + exec

exec.Command(...).Start() is two classic syscalls in a trench coat:

graph LR
P["parent process"] -->|"fork(2)"| C["child: a clone of the parent"]
C -->|"execve(2)"| N["child's memory replaced<br/>by the new program"]
P -->|"wait4(2)"| R["reap exit status<br/>(ProcessState)"]

• fork duplicates the calling process, giving a child with copies of its fds and memory (copy-on-write).
• execve then replaces that child’s program image with the new binary — same PID, brand-new code.
• wait lets the parent collect the child’s exit status. Until it does, a finished child is a zombie holding a slot in the process table.

Go hides all three: Start does the fork+exec, and Wait (or Run/Output, which call it) does the reaping and fills in cmd.ProcessState:

cmd := exec.Command("false") // exits non-zero
err := cmd.Run()
var ee *exec.ExitError
if errors.As(err, &ee) {
	fmt.Println("exit code:", ee.ExitCode())          // 1
	fmt.Println("user CPU time:", ee.UserTime())       // from ProcessState
}

So “always Wait()” isn’t style advice — it’s how you reap the zombie. And the child inheriting fds is exactly what makes pipes between parent and child work: the parent’s os.Pipe write end survives the fork into the child.

See also

• signals — sending/handling signals to control processes.
• pipes — wiring one process’s output into another’s input.
• os/exec (stdlib) — the package in depth, including security.
• context & cancellation (patterns) — the leash for CommandContext.

Next: how a process reacts to the outside world — signals.

Related topics