Что такое синхронное взаимодействие?

Синхронное взаимодействие

Синхронное взаимодействие (Synchronous Communication) — это модель обмена данными между компонентами или сервисами, при которой отправитель ждёт ответа от получателя перед тем, как продолжить своё выполнение. Отправитель блокируется до получения результата.

Основная идея

В синхронном взаимодействии происходит следующее:

Клиент                          Сервер
   |
   |--- Запрос --------------->
   |  (блокировка ожидания)    |
   |                           | Обработка
   |                           |
   |<-- Ответ ------------------|
   |
   | Продолжение работы
   |

Клиент отправляет запрос и жёстко ждёт ответа. Во время ожидания его поток приостановлен и не может выполнять другие задачи.

Примеры синхронного взаимодействия в Java

1. Синхронный HTTP запрос

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class SynchronousHttpClient {
    public static void main(String[] args) throws Exception {
        // Отправляем запрос и ждём ответа
        URL url = new URL("https://api.example.com/users/123");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        
        // БЛОКИРУЕМСЯ здесь в ожидании ответа
        int responseCode = conn.getResponseCode();
        
        BufferedReader in = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        
        StringBuilder response = new StringBuilder();
        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();
        
        System.out.println("Ответ получен: " + response.toString());
        System.out.println("Продолжение работы");
    }
}

2. Синхронный вызов REST API через RestTemplate (Spring)

import org.springframework.web.client.RestTemplate;

@Service
public class UserService {
    private RestTemplate restTemplate;
    
    public UserDTO getUserById(Long id) {
        // Синхронный вызов — ждём ответа
        UserDTO user = restTemplate.getForObject(
            "https://api.example.com/users/" + id,
            UserDTO.class
        );
        // Эта строка не выполнится, пока не придёт ответ
        System.out.println("Пользователь получен: " + user.getName());
        return user;
    }
}

3. Синхронный вызов метода в том же потоке

public class DataProcessor {
    public String fetchData() {
        // Синхронный вызов
        String result = slowDatabaseQuery();  // БЛОКИРУЕМСЯ здесь
        System.out.println("Данные получены: " + result);
        return result;
    }
    
    public String slowDatabaseQuery() {
        // Имитация долгого запроса
        try {
            Thread.sleep(5000);  // 5 секунд
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "SELECT * FROM users";
    }
}

4. Синхронный RPC (Remote Procedure Call)

public class SyncRpcExample {
    private RemoteService remoteService;
    
    public void processOrder(Order order) {
        // Синхронный вызов удалённого сервиса
        PaymentResult payment = remoteService.processPayment(order.getAmount());
        // Ждём результата платежа
        if (payment.isSuccess()) {
            remoteService.updateInventory(order.getItems());
            remoteService.sendConfirmationEmail(order.getEmail());
        }
    }
}

Преимущества синхронного взаимодействия

✅ Простота реализации

• Код выглядит как обычный, последовательный вызов функций
• Не нужно работать с коллбэками или Future

✅ Предсказуемость и контроль ошибок

• Ошибки легко перехватываются через try-catch
• Порядок выполнения ясен и линеен

✅ Удобство отладки

• Легче поставить точку останова
• Стектрейс показывает полную цепочку вызовов

✅ Транзакционность

try {
    userService.createUser(user);        // синх.
    paymentService.processPayment(order);  // синх.
    notificationService.sendEmail(user);   // синх.
    // Все три операции в одной транзакции
} catch (Exception e) {
    // Откатить всё
}

Недостатки синхронного взаимодействия

❌ Низкая масштабируемость

Каждый запрос требует отдельного потока, который блокируется:

// С 1000 одновременных клиентов нужно 1000 потоков
// Каждый поток потребляет ~1-2 МБ памяти
// 1000 потоков = ~2 ГБ памяти

❌ Низкая производительность при высокой нагрузке

Время обработки: 1 сек
Одновременные запросы: 1000
Общее время: 1000 сек (если нет параллелизма)

❌ Проблемы с timeout

Если сервер не ответит в срок, клиент зависнет или получит исключение.

❌ Слабая устойчивость к сбоям

Если сервер недоступен, клиент блокируется вместо переключения на другой сервер.

Синхронное vs Асинхронное

Когда использовать синхронное взаимодействие

✅ Используйте, когда:

• Нагрузка невысокая (< 100 одновременных запросов)
• Время ответа критично для пользователя
• Код должен быть простым и понятным
• Нужна строгая транзакционность

❌ Избегайте, когда:

• Ожидается высокая нагрузка (> 1000 одновременных запросов)
• Время отклика не критично
• Нужна высокая масштабируемость
• Сервис может быть медленным или недоступным

Практический пример: Spring Boot Controller

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@RequestBody OrderRequest request) {
        // Синхронный вызов — контроллер ждёт результата
        OrderDTO order = orderService.createOrder(request);
        // Только после получения результата отправляем ответ
        return ResponseEntity.ok(order);
    }
}

Синхронное взаимодействие — это стандартный, наиболее интуитивный способ взаимодействия между компонентами. Однако для высоконагруженных систем следует рассматривать асинхронные подходы.