Расскажи про свой опыт работы с транзакцией

Мой опыт работы с транзакциями в PHP

Мой опыт работы с транзакциями охватывает более 10 лет разработки на PHP с различными базами данных, включая MySQL, PostgreSQL и Redis. Я использовал транзакции для обеспечения целостности данных в высоконагруженных приложениях, где атомарность операций была критически важной.

Основные сценарии применения

1. Финансовые операции:

try {
    $pdo->beginTransaction();
    
    // Списание с одного счета
    $stmt = $pdo->prepare("UPDATE accounts SET balance = balance - ? WHERE id = ?");
    $stmt->execute([$amount, $fromAccountId]);
    
    // Зачисление на другой счет
    $stmt = $pdo->prepare("UPDATE accounts SET balance = balance + ? WHERE id = ?");
    $stmt->execute([$amount, $toAccountId]);
    
    // Запись в журнал операций
    $stmt = $pdo->prepare("INSERT INTO transaction_log (from_account, to_account, amount) VALUES (?, ?, ?)");
    $stmt->execute([$fromAccountId, $toAccountId, $amount]);
    
    $pdo->commit();
    
} catch (Exception $e) {
    $pdo->rollBack();
    throw new TransactionException("Transfer failed: " . $e->getMessage());
}

2. Сложные регистрационные процессы:

public function registerUser(UserDTO $userData): User
{
    $this->db->beginTransaction();
    
    try {
        // Создание пользователя
        $userId = $this->userRepository->create($userData);
        
        // Создание профиля
        $this->profileRepository->createDefaultProfile($userId);
        
        // Назначение ролей
        $this->roleRepository->assignDefaultRoles($userId);
        
        // Отправка приветственного письма (вне транзакции)
        $this->db->commit();
        
        $this->emailService->sendWelcomeEmail($userId);
        
        return $this->userRepository->findById($userId);
        
    } catch (\Exception $e) {
        $this->db->rollBack();
        \Log::error("User registration failed: " . $e->getMessage());
        throw new RegistrationException("Registration failed", 0, $e);
    }
}

Продвинутые паттерны работы с транзакциями

Распределенные транзакции: В микросервисной архитектуре я реализовывал Saga Pattern для координации транзакций между сервисами:

class OrderSaga {
    public function createOrder(OrderRequest $request): OrderResult
    {
        $sagaId = Uuid::uuid4();
        
        try {
            // 1. Резервирование товаров
            $inventoryResult = $this->inventoryService->reserveItems(
                $request->items, 
                $sagaId
            );
            
            // 2. Создание платежа
            $paymentResult = $this->paymentService->createPayment(
                $request->paymentData,
                $sagaId
            );
            
            // 3. Создание заказа
            $order = $this->orderService->createOrder(
                $request, 
                $sagaId,
                $inventoryResult->reservationId,
                $paymentResult->paymentId
            );
            
            return new OrderResult($order, true);
            
        } catch (\Exception $e) {
            // Компенсирующие транзакции
            $this->compensate($sagaId);
            throw new OrderCreationException($e->getMessage());
        }
    }
    
    private function compensate(string $sagaId): void
    {
        $this->inventoryService->cancelReservation($sagaId);
        $this->paymentService->cancelPayment($sagaId);
    }
}

Оптимизация производительности

Уровни изоляции: Я выбирал подходящий уровень изоляции в зависимости от требований:

• READ COMMITTED для большинства операций
• REPEATABLE READ для финансовых отчетов
• SERIALIZABLE только для критически важных данных

// Установка уровня изоляции
$pdo->exec("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ");
$pdo->beginTransaction();

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

$batchSize = 1000;
$pdo->beginTransaction();

for ($i = 0; $i < count($data); $i += $batchSize) {
    $batch = array_slice($data, $i, $batchSize);
    $this->processBatch($batch);
    
    // Периодический коммит для уменьшения блокировок
    if ($i % 10000 === 0) {
        $pdo->commit();
        $pdo->beginTransaction();
    }
}

$pdo->commit();

Проблемы и их решения

1. Дедлоки:

// Стратегия повторных попыток
function executeWithRetry(callable $operation, int $maxRetries = 3): mixed
{
    for ($attempt = 1; $attempt <= $maxRetries; $attempt++) {
        try {
            return $operation();
        } catch (\PDOException $e) {
            if (strpos($e->getMessage(), 'Deadlock') === false || $attempt === $maxRetries) {
                throw $e;
            }
            usleep(100 * $attempt); // Экспоненциальная задержка
        }
    }
}

2. Долгие транзакции:

• Установка таймаутов: SET SESSION innodb_lock_wait_timeout = 10
• Разбиение больших транзакций на меньшие
• Использование оптимистичных блокировок через версионирование

3. Мониторинг:

-- Отслеживание активных транзакций
SHOW ENGINE INNODB STATUS;
SELECT * FROM information_schema.INNODB_TRX;

Интеграция с ORM

В Laravel и Symfony использовал встроенные механизмы транзакций:

// Laravel
DB::transaction(function () use ($user, $order) {
    $user->save();
    $order->user_id = $user->id;
    $order->save();
}, 3); // 3 попытки при дедлоке

// Symfony с Doctrine
$entityManager->beginTransaction();
try {
    $entityManager->persist($entity);
    $entityManager->flush();
    $entityManager->commit();
} catch (\Exception $e) {
    $entityManager->rollback();
    throw $e;
}

Выводы и лучшие практики

Из моего опыта я вывел несколько ключевых принципов:

1. Минимизируйте время транзакций - выполняйте только необходимые операции внутри транзакции
2. Обрабатывайте исключения правильно - всегда предусматривайте rollback
3. Тестируйте edge cases - дедлоки, таймауты, отказы сети
4. Используйте подходящий уровень изоляции - более высокие уровни снижают производительность
5. Логируйте важные транзакции для аудита и отладки
6. Избегайте транзакций в циклах - группируйте операции

Транзакции - мощный инструмент, но требуют глубокого понимания как работы СУБД, так и бизнес-логики приложения. Правильное использование транзакций значительно повышает надежность и консистентность данных в распределенных системах.