GoLang Tutorial - Panic and Recover

Continued from Defer.

Panic is similar to throwing an exception. In other words, a panic is an exception in Go. A panic is caused either by a runtime error, or an explicit call to the built-in panic function.

When a panic is called normal execution of a goroutine is stopped immediately:

1. When a program panics, it immediately starts to unwind the call stack.
2. This continues until the program crashes and prints a stack trace, or until the built-in recover function is called.

A panic is caused either by a runtime error or an explicit call to the built-in panic function.

A program recovers from a panic by calling the built-in function recover, after which normal execution is resumed. Since all the functions ordinary code is skipped during a panic, the only chance we have to call recover is from within a deferred function as shown in the picture below.

Picture credit: Go: Recover from a panic

During normal operation the recover function returns nil:

When panic() is called, the recover function returns whatever we gave as argument (in this case, it's "Argh!") to the panic function:

Here is a sample for the panic and recover from Go's blog:

The code: defer-panic-recover.go

The function g() takes the int i, and panics if i is greater than 3, or else it calls itself with the argument i+1. The function f() defers a function that calls recover and prints the recovered value (if it is non-nil).

If we remove the deferred function from f() the panic is not recovered and reaches the top of the goroutine's call stack, terminating the program:

The code: defer-panic-recover-2.go

The output now looks like this:

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)