What is the difference between synchronous and asynchronous communication?

Question

Accepted Answer

**Synchronous** — the caller sends a request and blocks until it receives a response. **Asynchronous** — the caller sends a message and continues immediately without waiting for a response. **System Design Context:** The choice between sync and async communication is fundamental to microservices architecture. Synchronous is simpler but creates tight coupling and latency chains. Async is more resilient but introduces eventual consistency and debugging complexity. **Synchronous (REST/gRPC) — Detailed:** - **Request-response model** — caller blocks until response arrives. - **Immediate feedback** — caller knows the result right away. - **Tight coupling** — if the called service is down, the caller fails. - **Latency chain** — total latency = sum of all service latencies. - **Thread consumption** — each blocked call holds a thread. ```java // Synchronous REST call — blocks the thread @RestController @RequestMapping("/api/orders") public class OrderController { private final UserServiceClient userServiceClient; private final InventoryServiceClient inventoryClient; @GetMapping("/{id}") public OrderDTO getOrder(@PathVariable Long id) { Order order = orderService.findById(id); User user = userServiceClient.getUser(order.getUserId()); // blocks for 50ms List items = inventoryClient.getItems(order.getItemIds()); // blocks for another 100ms return OrderDTO.from(order, user, items); // Total: 150ms minimum } } // Optimized with parallel calls (still synchronous) @GetMapping("/{id}/optimized") public CompletableFuture getOrderOptimized(@PathVariable Long id) { Order order = orderService.findById(id); CompletableFuture userFuture = CompletableFuture .supplyAsync(() -> userServiceClient.getUser(order.getUserId())); CompletableFuture> itemsFuture = CompletableFuture .supplyAsync(() -> inventoryClient.getItems(order.getItemIds())); return userFuture.thenCombine(itemsFuture, (user, items) -> OrderDTO.from(order, user, items)); // Total: ~100ms (max of the two parallel calls) } ``` **Asynchronous (Kafka/RabbitMQ) — Detailed:** - **Message-based** — events are published to a broker. - **Fire and forget** — caller continues immediately. - **Loose coupling** — services don't know about each other. - **Eventual consistency** — data may be temporarily inconsistent. - **Resilience** — if consumer is down, messages queue up. ```java // Asynchronous event publishing @Service @Transactional public class OrderService { private final OrderRepository orderRepo; private final KafkaTemplate kafkaTemplate; public Order createOrder(CreateOrderRequest request) { Order order = new Order(request); Order saved = orderRepo.save(order); // Publish event — doesn't wait for notification service kafkaTemplate.send("order-events", new OrderCreatedEvent(saved.getId(), saved.getUserId(), saved.getTotal(), Instant.now())); return saved; // Total: ~10ms (just DB save + async publish) } } // Async consumer — processes events independently @Service @Slf4j public class NotificationListener { @KafkaListener(topics = "order-events", groupId = "notification-service") public void onOrderCreated(OrderCreatedEvent event) { log.info("Processing order event: {}", event.orderId()); emailService.sendOrderConfirmation(event.userId(), event.orderId()); inventoryService.reserve(event.orderId()); } } ``` **Trade-offs Summary:** - Synchronous: simpler debugging, immediate consistency, but tight coupling and latency chains. - Asynchronous: better resilience, loose coupling, but eventual consistency and complex debugging. **When to Use:** - **Synchronous** — real-time data, critical operations (payment, authentication), user-facing queries. - **Asynchronous** — notifications, emails, analytics, non-critical processing, event-driven workflows.

Java: What is the difference between synchronous and asynchronous communication?