Обработка ошибок в Go: panic, defer и recover

В этом уроке мы изучим механизмы обработки ошибок в Go, включая панику, отложенные вызовы и восстановление. Эти инструменты позволяют создавать надёжные программы, которые могут корректно обрабатывать исключительные ситуации.

Почему важна обработка ошибок?

Правильная обработка ошибок необходима для:

Предотвращения аварийного завершения программ
Корректного освобождения ресурсов
Обеспечения предсказуемого поведения
Улучшения отладки
Создания надёжных систем

💡 Интересный факт: В Go нет традиционных исключений (try-catch). Вместо этого используются возврат ошибок и механизм panic/recover.

Основы обработки ошибок

1. Паника (panic)

func SafeOperation() {
    // Отложенная функция для восстановления после паники
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Восстановлено после паники: %v\n", r)
        }
    }()

    // Критическая операция
    if err := CriticalOperation(); err != nil {
        panic(fmt.Sprintf("Критическая ошибка: %v", err))
    }
}

func CriticalOperation() error {
    // Имитация критической ошибки
    return fmt.Errorf("недостаточно ресурсов")
}

func main() {
    SafeOperation()
}

Объяснение:

Функция SafeOperation демонстрирует безопасное выполнение критических операций
defer с recover гарантирует, что даже при панике программа не завершится аварийно
CriticalOperation имитирует возникновение критической ошибки

Ожидаемый вывод:

Восстановлено после паники: Критическая ошибка: недостаточно ресурсов

2. Отложенные вызовы (defer)

func ProcessFile(filename string) error {
    // Открытие файла с обработкой ошибок
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("ошибка открытия файла: %v", err)
    }
    // Гарантированное закрытие файла при выходе из функции
    defer file.Close()

    // Чтение данных из файла
    data, err := io.ReadAll(file)
    if err != nil {
        return fmt.Errorf("ошибка чтения файла: %v", err)
    }

    fmt.Printf("Прочитано %d байт из файла\n", len(data))
    return nil
}

func main() {
    if err := ProcessFile("example.txt"); err != nil {
        fmt.Printf("Ошибка: %v\n", err)
    }
}

Объяснение:

Функция ProcessFile демонстрирует безопасную работу с файлами
defer file.Close() гарантирует закрытие файла даже при возникновении ошибок
Обработка ошибок на каждом этапе работы с файлом

Ожидаемый вывод:

Прочитано 1024 байт из файла

или при ошибке:

Ошибка: ошибка открытия файла: файл не найден

Продвинутые техники

1. Множественные defer

func ComplexOperation() {
    fmt.Println("Начало операции")
    
    // Отложенные операции выполняются в обратном порядке
    defer fmt.Println("Очистка ресурсов")
    defer fmt.Println("Закрытие соединений")
    defer fmt.Println("Завершение транзакций")
    
    // Основная логика
    fmt.Println("Выполнение операции")
}

func main() {
    ComplexOperation()
}

Объяснение:

Демонстрирует порядок выполнения множественных defer
Показывает, как организовать последовательность очистки ресурсов
Важен порядок объявления defer - последний объявленный выполняется первым

Ожидаемый вывод:

Начало операции
Выполнение операции
Завершение транзакций
Закрытие соединений
Очистка ресурсов

2. Восстановление с контекстом

func SafeOperationWithContext() {
    defer func() {
        if r := recover(); r != nil {
            // Добавление контекста к ошибке
            err := fmt.Errorf("операция завершилась с ошибкой: %v", r)
            // Логирование ошибки
            log.Printf("Ошибка: %v", err)
            // Возврат ошибки выше
            panic(err)
        }
    }()

    // Опасная операция
    DangerousOperation()
}

func DangerousOperation() {
    panic("критическая ошибка в DangerousOperation")
}

func main() {
    SafeOperationWithContext()
}

Объяснение:

Показывает, как добавить контекст к ошибке при восстановлении
Демонстрирует многоуровневую обработку ошибок
Включает логирование для отладки

Ожидаемый вывод:

2023/01/01 12:00:00 Ошибка: операция завершилась с ошибкой: критическая ошибка в DangerousOperation

3. Отложенные функции с параметрами

func DeferredParameters() {
    value := "начальное значение"
    
    // Параметры функции в defer фиксируются в момент объявления
    defer func(v string) {
        fmt.Printf("Отложенное значение: %s\n", v)
    }(value)
    
    // Изменение значения не влияет на отложенную функцию
    value = "новое значение"
    fmt.Printf("Текущее значение: %s\n", value)
}

func main() {
    DeferredParameters()
}

Объяснение:

Демонстрирует, как параметры фиксируются в момент объявления defer
Показывает разницу между текущим и отложенным значением
Важно для понимания времени выполнения отложенных функций

Ожидаемый вывод:

Текущее значение: новое значение
Отложенное значение: начальное значение

Практические примеры

1. Транзакции в базе данных

type Transaction struct {
    db *sql.DB
}

func (t *Transaction) Execute() error {
    // Начало транзакции
    tx, err := t.db.Begin()
    if err != nil {
        return fmt.Errorf("ошибка начала транзакции: %v", err)
    }
    
    // Гарантированный откат при панике
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
            panic(r)
        }
    }()
    
    // Выполнение операций
    if err := t.performOperations(tx); err != nil {
        tx.Rollback()
        return err
    }
    
    // Подтверждение транзакции
    return tx.Commit()
}

func main() {
    db := connectToDB()
    tx := &Transaction{db: db}
    
    if err := tx.Execute(); err != nil {
        fmt.Printf("Ошибка транзакции: %v\n", err)
    }
}

Объяснение:

Демонстрирует атомарность транзакций
Показывает безопасное выполнение операций с БД
Гарантирует откат при ошибках

Ожидаемый вывод при успехе:

Транзакция успешно выполнена

или при ошибке:

Ошибка транзакции: ошибка выполнения операций: недостаточно средств

2. Управление ресурсами

type ResourceManager struct {
    resources []Resource
    mu        sync.Mutex
}

func (rm *ResourceManager) Acquire() (Resource, error) {
    rm.mu.Lock()
    // Гарантированное освобождение мьютекса
    defer rm.mu.Unlock()
    
    if len(rm.resources) == 0 {
        return nil, fmt.Errorf("нет доступных ресурсов")
    }
    
    resource := rm.resources[0]
    rm.resources = rm.resources[1:]
    
    return resource, nil
}

func (rm *ResourceManager) Release(resource Resource) {
    rm.mu.Lock()
    defer rm.mu.Unlock()
    
    rm.resources = append(rm.resources, resource)
}

func main() {
    rm := &ResourceManager{
        resources: make([]Resource, 5),
    }
    
    res, err := rm.Acquire()
    if err != nil {
        fmt.Printf("Ошибка: %v\n", err)
        return
    }
    
    defer rm.Release(res)
    // Использование ресурса
}

Объяснение:

Демонстрирует безопасное управление пулом ресурсов
Показывает использование мьютексов для синхронизации
Гарантирует освобождение ресурсов

Ожидаемый вывод:

Ресурс успешно получен
Ресурс освобождён

Практические задания

Задание 1: Система обработки транзакций

Создайте систему для обработки финансовых транзакций:

Реализуйте механизм отката транзакций
Добавьте обработку критических ошибок
Обеспечьте атомарность операций
Реализуйте логирование ошибок

Ожидаемый результат:

Безопасное выполнение транзакций
Корректный откат при ошибках
Подробное логирование всех операций

Задание 2: Менеджер соединений

Разработайте систему управления сетевыми соединениями:

Создайте пул соединений
Реализуйте безопасное освобождение ресурсов
Добавьте обработку разрывов соединений
Обеспечьте переподключение при ошибках

Ожидаемый результат:

Эффективное использование соединений
Автоматическое восстановление при сбоях
Мониторинг состояния соединений

Задание 3: Система обработки файлов

Создайте систему для безопасной работы с файлами:

Реализуйте безопасное открытие/закрытие файлов
Добавьте обработку ошибок доступа
Обеспечьте корректное освобождение ресурсов
Реализуйте механизм восстановления после сбоев

Ожидаемый результат:

Надёжная работа с файлами
Корректная обработка ошибок доступа
Автоматическое освобождение ресурсов

Что дальше?

В следующем уроке мы:

Изучим работу с горутинами
Познакомимся с каналами
Узнаем о синхронизации
Начнём писать параллельные программы

🎯 Цель урока: К концу этого урока вы должны уметь:

Использовать panic и recover

Применять defer для управления ресурсами

Обрабатывать критические ошибки

Создавать надёжные системы

Курс по Golang