Synchronous vs Asynchronous Processing

Synchronous Processing

// Synchronous: Wait for completion
public function saveProduct($product)
{
    // 1. Save to database (wait)
    $this->resourceModel->save($product);
    
    // 2. Update search index (wait)
    $this->searchIndexer->reindexProduct($product->getId());
    
    // 3. Send notification (wait)
    $this->notifier->sendProductUpdate($product);
    
    // 4. Return response
    return $product;
}
// Total time: 100ms + 200ms + 300ms = 600ms
// Customer waits 600ms

Asynchronous Processing

// Asynchronous: Queue for later processing
public function saveProduct($product)
{
    // 1. Save to database (wait)
    $this->resourceModel->save($product);
    
    // 2. Queue search reindex (don't wait)
    $this->queue->sendMessage('product_reindex', [
        'product_id' => $product->getId()
    ]);
    
    // 3. Queue notification (don't wait)
    $this->queue->sendMessage('product_notification', [
        'product_id' => $product->getId()
    ]);
    
    // 4. Return response immediately
    return $product;
}
// Total time: 100ms (database only)
// Customer waits 100ms
// Background workers process queue

Strong Consistency (Sync)

// Synchronous: Guaranteed completion
public function processOrder($order)
{
    // All operations must succeed
    $this->db->beginTransaction();
    try {
        $this->saveOrder($order);
        $this->updateInventory($order);
        $this->processPayment($order);
        $this->sendConfirmation($order);
        $this->db->commit();
    } catch (\Exception $e) {
        $this->db->rollBack();
        throw $e;
    }
}
// Pros: Data always consistent
// Cons: Slow, single point of failure

Eventual Consistency (Async)

// Asynchronous: Eventual consistency
public function processOrder($order)
{
    // Save order (critical path)
    $this->saveOrder($order);
    
    // Queue other operations
    $this->queue->sendMessage('update_inventory', $order->getData());
    $this->queue->sendMessage('process_payment', $order->getData());
    $this->queue->sendMessage('send_confirmation', $order->getData());
    
    // Order is "saved" but not fully processed
    // Inventory, payment, confirmation happen later
}
// Pros: Fast response, better UX
// Cons: Temporary inconsistency possible

Consistency Scenarios

Scenario: Order placed, inventory not updated yet

Sync:
├── Order saved ✓
├── Inventory updated ✓
├── Payment processed ✓
└── Response sent (600ms)

Async:
├── Order saved ✓
├── Response sent (100ms)
├── Inventory updated (background)
├── Payment processed (background)
└── Confirmation sent (background)

Risk: Customer orders, another customer buys same item
Solution: Reserve inventory synchronously, fulfill async

Response Time

// Synchronous: Cumulative response time
// Product save: 100ms
// Index update: 200ms
// Notification: 300ms
// Total: 600ms

// Asynchronous: Only critical path
// Product save: 100ms
// Queue messages: 10ms
// Total: 110ms

// Improvement: 82% faster response

Throughput

Synchronous:
├── 100 requests/sec
├── Each request: 600ms
├── Thread blocked for 600ms
└── Limited by slowest operation

Asynchronous:
├── 1000 requests/sec (critical path)
├── Each request: 110ms
├── Thread freed quickly
└── Queue workers process independently

// 10x throughput improvement

Resource Utilization

// Synchronous: Resources held during processing
// Database connection: 600ms
// Memory: 600ms
// CPU: 600ms

// Asynchronous: Resources released quickly
// Database connection: 100ms
// Memory: 100ms
// CPU: 100ms
// Queue worker: Separate resources

// Better resource efficiency with async

Failure Impact

Synchronous failure:
├── Payment gateway timeout (5s)
├── Customer waits 5 seconds
├── Request fails
└── User experience: Poor

Asynchronous failure:
├── Payment queued for processing
├── Customer gets immediate response
├── Payment processed in background
├── If fails: Retry, notification
└── User experience: Good (with fallback)

Magento 2 Message Queue

// Producer: Send message
$this->queue->sendMessage('product.reindex', [
    'product_id' => $productId,
    'store_id' => $storeId
]);

// Consumer: Process message
class ProductReindexConsumer
{
    public function process(MessageInterface $message)
    {
        $data = json_decode($message->getBody(), true);
        $this->reindexer->reindexProduct($data['product_id']);
    }
}

// queue_consumer.xml
<config>
    <queue name="product.reindex">
        <consumer name="product.reindex.consumer"
                  queue="product.reindex"
                  handler="Vendor\Module\Consumer\ProductReindexConsumer::process"/>
    </queue>
</config>

Hybrid Approach

// Critical path: Sync
// Non-critical: Async
public function processOrder($order)
{
    // Sync: Save order (critical)
    $this->saveOrder($order);
    
    // Sync: Reserve inventory (critical)
    $this->reserveInventory($order);
    
    // Async: Process payment
    $this->queue->sendMessage('payment.process', $order->getData());
    
    // Async: Send confirmation
    $this->queue->sendMessage('email.confirmation', $order->getData());
    
    // Async: Update analytics
    $this->queue->sendMessage('analytics.order', $order->getData());
    
    return $order;
}

Error Handling

// Sync error handling
try {
    $this->processOrder($order);
} catch (\Exception $e) {
    $this->logger->error($e->getMessage());
    throw new \Magento\Framework\Exception\LocalizedException(
        __('Order processing failed')
    );
}

// Async error handling with retry
$this->queue->sendMessage('payment.process', $order->getData(), [
    'max_retries' => 3,
    'retry_delay' => 60,
    'dead_letter_queue' => 'payment.failed'
]);

// Dead letter queue processing
public function processFailedPayment($message)
{
    $this->logger->critical('Payment failed permanently', $message->getData());
    $this->adminNotifier->notify('Payment requires manual processing');
}