Terminating a Process Started with os/exec in Golang

by

Run and terminate an exec.Process:

// Start a process:
cmd := exec.Command("sleep", "5")
if err := cmd.Start(); err != nil {
    log.Fatal(err)
}

// Kill it:
if err := cmd.Process.Kill(); err != nil {
    log.Fatal("failed to kill process: ", err)
}

Run and terminate an exec.Process after a timeout:

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

if err := exec.CommandContext(ctx, "sleep", "5").Run(); err != nil {
    // This will fail after 3 seconds. The 5 second sleep
    // will be interrupted.
}

See this example in the Go docs

Legacy

Before Go 1.7, we didn’t have the context package and this answer was different.

Run and terminate an exec.Process after a timeout using channels and a goroutine:

// Start a process:
cmd := exec.Command("sleep", "5")
if err := cmd.Start(); err != nil {
    log.Fatal(err)
}

// Wait for the process to finish or kill it after a timeout (whichever happens first):
done := make(chan error, 1)
go func() {
    done <- cmd.Wait()
}()
select {
case <-time.After(3 * time.Second):
    if err := cmd.Process.Kill(); err != nil {
        log.Fatal("failed to kill process: ", err)
    }
    log.Println("process killed as timeout reached")
case err := <-done:
    if err != nil {
        log.Fatalf("process finished with error = %v", err)
    }
    log.Print("process finished successfully")
}

Either the process ends and its error (if any) is received through done or 3 seconds have passed and the program is killed before it’s finished.

More Related Contents:

  1. Create a generic channel
  2. How to use a module that is outside of “GOPATH” in another module?
  3. slice of struct != slice of interface it implements?
  4. How can I convert string to integer in golang
  5. Does Go compiler’s evaluation differ for constant expression and other expression
  6. Cyclic dependencies and interfaces
  7. Accessing struct fields inside a map value (without copying)
  8. Can I concurrently write different slice elements
  9. Golang Dependency Management Best Practice
  10. How can I pass a slice as a variadic input?
  11. Does Go provide REPL?
  12. How to compare if two structs, slices or maps are equal?
  13. Golang defer behavior
  14. Example for sync.WaitGroup correct?
  15. Stack vs heap allocation of structs in Go, and how they relate to garbage collection
  16. Is unnamed arguments a thing in Go?
  17. How to fix parsing go.mod module declares its path as “x” but was required as “y”
  18. What is the idiomatic Go equivalent of C’s ternary operator?
  19. Can I construct a slice of a generic type with different type parameters?
  20. Why would I make() or new()?
  21. How to import local packages in go?
  22. How to implement generic interfaces?
  23. How to compare Go errors
  24. How do you get the output of a system command in Go?
  25. How do you statically link a c library in go using cgo?
  26. Capture or assign golang template output to variable
  27. When is the init() function run?
  28. Is there a queue implementation?
  29. How to iterate over a union of slices passed in a generic function? (T has no core type)
  30. Registering packages in Go without cyclic dependency

Leave a Comment