Error handling and defer in Go (Concurrency and synchronization) | Patterns, idioms, and best practices in Go

Error handling in Go is significantly different from the familiar Java approach with exceptions. Instead of try/catch, Go uses returning an error as a separate value, and `defer` helps safely release resources regardless of whether an error occurred or not.

1. Error handling idioms

Error handling idioms - Explicit error checking ⚠️. errors are returned and checked immediately after the call

In Go, it is customary to return an error as the second value of a function and check it immediately. This is a simple but powerful idiom.

// Go: error checking
func readFile(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err // return error up
    }
    return data, nil
}

func main() {
    content, err := readFile("file.txt")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(string(content))
}

// Java: error checking via exception
try {
    byte[] content = Files.readAllBytes(Paths.get("file.txt"));
    System.out.println(new String(content));
} catch (IOException e) {
    System.out.println("Error: " + e.getMessage());
}

In Go, error handling is explicit and local. This allows you to immediately see where a problem may arise, without hidden exceptions.

2. defer for cleanup

Error handling idioms - Explicit error checking ⚠️. errors are returned and checked immediately after the call

`defer` allows postponing the execution of a function until exiting the current function. Very convenient for releasing resources: closing files, connections, mutexes, etc.

// Go: defer for closing a file
func processFile(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }
    defer file.Close() // guaranteed closure on any exit from the function

    // reading the file
    content, err := io.ReadAll(file)
    if err != nil {
        return err
    }
    fmt.Println(string(content))
    return nil
}

// Java: try-with-resources
try (FileInputStream file = new FileInputStream("file.txt")) {
    byte[] content = file.readAllBytes();
    System.out.println(new String(content));
} catch (IOException e) {
    System.out.println("Error: " + e.getMessage());
}

defer guarantees that resources will be released even if an error occurs in the function. This makes the code cleaner and safer.

3. Common Patterns and Tips

• Check for errors immediately after calling functions: if err != nil.
• Use defer to release any resources: files, connections, locks.
• You can defer multiple calls — they execute in reverse order (stack).
• Don't use panic for ordinary errors — only for truly critical situations.
• For Java developers: defer ≈ try-with-resources, explicit error checking ≈ catch/throw, but without exceptions.

The combination of explicit error checking and defer allows writing reliable code that is safe in a multithreaded or parallel context.