How to exit a go program honoring deferred calls?
Solution 1
runtime.Goexit()
is the easy way to accomplish that.
Goexit terminates the goroutine that calls it. No other goroutine is affected. Goexit runs all deferred calls before terminating the goroutine. Because Goexit is not panic, however, any recover calls in those deferred functions will return nil.
However:
Calling Goexit from the main goroutine terminates that goroutine without func main returning. Since func main has not returned, the program continues execution of other goroutines. If all other goroutines exit, the program crashes.
So if you call it from the main goroutine, at the top of main
you need to add
defer os.Exit(0)
Below that you might want to add some other defer
statements that inform the other goroutines to stop and clean up.
Solution 2
Just move your program down a level and return your exit code:
package main
import "fmt"
import "os"
func doTheStuff() int {
defer fmt.Println("!")
return 3
}
func main() {
os.Exit(doTheStuff())
}
Solution 3
After some research, refer to this this, I found an alternative that:
- Doesn't impose a certain architecture like in https://stackoverflow.com/a/27629493/438563
- Doesn't require any global value like in https://stackoverflow.com/a/24601700/438563
We can take advantage of panic
and recover
. It turns out that panic
, by nature, will honor defer
calls but will also always exit with non 0
status code and dump a stack trace. The trick is that we can override last aspect of panic behavior with:
package main
import "fmt"
import "os"
type Exit struct{ Code int }
// exit code handler
func handleExit() {
if e := recover(); e != nil {
if exit, ok := e.(Exit); ok == true {
os.Exit(exit.Code)
}
panic(e) // not an Exit, bubble up
}
}
Now, to exit a program at any point and still preserve any declared defer
instruction we just need to emit an Exit
type:
func main() {
defer handleExit() // plug the exit handler
defer fmt.Println("cleaning...")
panic(Exit{3}) // 3 is the exit code
}
It doesn't require any refactoring apart from plugging a line inside func main
:
func main() {
defer handleExit()
// ready to go
}
This scales pretty well with larger code bases so I'll leave it available for scrutinization. Hope it helps.
Playground: http://play.golang.org/p/4tyWwhcX0-
Solution 4
For posterity, for me this was a more elegant solution:
func main() {
retcode := 0
defer func() { os.Exit(retcode) }()
defer defer1()
defer defer2()
[...]
if err != nil {
retcode = 1
return
}
}
![marcio](https://i.stack.imgur.com/X5jns.jpg?s=256&g=1)
marcio
Contributor of many open source projects. Languages I work with: PHP Go Python Lisp Rebol and Red C (learning) C++ (learning)
Updated on December 08, 2021Comments
-
marcio over 2 years
I need to use
defer
to free allocations manually created usingC
library, but I also need toos.Exit
with non 0 status at some point. The tricky part is thatos.Exit
skips any deferred instruction:package main import "fmt" import "os" func main() { // `defer`s will _not_ be run when using `os.Exit`, so // this `fmt.Println` will never be called. defer fmt.Println("!") // sometimes ones might use defer to do critical operations // like close a database, remove a lock or free memory // Exit with status code. os.Exit(3) }
Playground: http://play.golang.org/p/CDiAh9SXRM stolen from https://gobyexample.com/exit
So how to exit a go program honoring declared
defer
calls? Is there any alternative toos.Exit
? -
marcio over 9 yearsSo I shouldn't to use
defer
insidefunc main
or any function that exits? -
Rob Napier over 9 yearsMore to the point, I don't recommend using
os.Exit()
in random places in the code. It makes testing very difficult besides the problem of error codes. peterSO's solution that @ctcherry links is ok, but it doesn't scale well IMO to a larger program. You'd have to make thecode
global. I believe you should keep main() fairly simple, and have it just take care of the OS-level things (like the final status code). -
marcio over 9 yearsHi, I found a way to handle this without impose any architecture. Anyway, +1 because it's a good advice to always try KISS first.
-
marcio over 7 yearsI had no idea
runtime.Goexit()
existed. Is this from some recent release? -
EMBLEM over 7 years@marcio I did some digging in the Go repositories. I couldn't find exactly when it was introduced, but I did find this test that references it and is "Copyright 2013" from before you posted this question.
-
EMBLEM over 7 years@marcio I did a little more digging and found an archive of the documentation from 2009. Goexit is listed there.
-
marcio over 7 yearsI'm gonna mark this as the accepted answer. The other answers are definitely still valid, but this seems the simplest approach - for now :D
-
xpt over 7 yearsBest answer of the all so far! One question, how to deal with normal exit then? How to make sure the
handleExit
get called even with normal exit ? Ref: play.golang.org/p/QDJum4kOXk un-comment the//panic
and see the difference. -
marcio over 7 yearsI think a handle for a normal exit 0 event doesn't exist, but you can always panic(Exit{0}) and then handle it or maybe defer handleNormalExit() before anything else on main()?
-
PRMan about 4 yearsThis really takes the best parts of the other answers.
-
Macindows almost 3 yearsI was breaking my head exploring different ways around this issue; why os.exit does not also call the "defer" functions but in my case simply using "return" instead of os.exit solved the issue. Now I feel stupid I didnt think of it earlier
-
Macindows almost 3 yearson a side note, does defer1, defer2 execute in chronological order?
-
Macindows almost 3 yearsYes, this sounds more like the exceptions bubbling in java/C#
-
Mike Gleason jr Couturier almost 3 years@Macindows This is Go standard: last to first. So
defer2()
, thendefer1()
-
rubens21 over 2 yearsThis code will suppress panics. Also, if
retcode
is not changed (during a panic, for example), it will return always 0 (no erro). If you are sure your code is panic free, you are probably fine with that, though