Как устранить проблему долгой обработки запросов, если в базе нет подвисаний

Диагностика и решение проблемы медленной обработки запросов на уровне приложения

Если база данных работает нормально, но запросы обрабатываются долго, проблема находится на уровне Java приложения. Нужно систематически проверить различные слои: логику приложения, сетевые операции, память и потоки.

Шаг 1: Профилирование приложения

Используй JVM профайлер для выявления узких мест:

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.lang.management.MemoryMXBean;

public class PerformanceMonitor {
    public static void analyzeRequest() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        long startTime = System.nanoTime();
        long startCpuTime = threadBean.getCurrentThreadCpuTime();
        long startMemory = Runtime.getRuntime().totalMemory();
        
        // Выполнить запрос
        processRequest();
        
        long endTime = System.nanoTime();
        long endCpuTime = threadBean.getCurrentThreadCpuTime();
        long endMemory = Runtime.getRuntime().totalMemory();
        
        System.out.println("Total time: " + (endTime - startTime) / 1_000_000 + "ms");
        System.out.println("CPU time: " + (endCpuTime - startCpuTime) / 1_000_000 + "ms");
        System.out.println("Memory change: " + (endMemory - startMemory) / 1024 + "KB");
    }
}

Шаг 2: Проверка логики обработки данных

Нечастая проблема — неэффективные алгоритмы в приложении:

// Плохо: O(n²) сложность
public List<User> filterUsers(List<User> users, List<String> ids) {
    List<User> result = new ArrayList<>();
    for (User user : users) {
        for (String id : ids) {
            if (user.getId().equals(id)) {
                result.add(user);
            }
        }
    }
    return result;
}

// Хорошо: O(n) сложность
public List<User> filterUsers(List<User> users, List<String> ids) {
    Set<String> idSet = new HashSet<>(ids);
    return users.stream()
        .filter(user -> idSet.contains(user.getId()))
        .collect(Collectors.toList());
}

Шаг 3: Оптимизация Stream операций

Stream API может быть неэффективным при неправильном использовании:

// Плохо: создание промежуточных списков
public List<Order> getActiveOrders() {
    return orders.stream()
        .filter(o -> o.isActive())
        .collect(Collectors.toList())
        .stream()
        .sorted(Comparator.comparing(Order::getDate))
        .collect(Collectors.toList());
}

// Хорошо: одна цепочка операций
public List<Order> getActiveOrders() {
    return orders.stream()
        .filter(Order::isActive)
        .sorted(Comparator.comparing(Order::getDate))
        .collect(Collectors.toList());
}

Шаг 4: Проверка внешних API вызовов

Часто задержка вызывается HTTP запросами к внешним сервисам:

// Плохо: синхронные последовательные вызовы
public OrderDetails getOrderDetails(String orderId) {
    Order order = apiClient.getOrder(orderId);      // Ждём 500ms
    User user = apiClient.getUser(order.getUserId()); // Ждём 300ms
    Inventory inv = apiClient.getInventory(order.getItemId()); // Ждём 400ms
    return new OrderDetails(order, user, inv);      // Итого 1200ms
}

// Хорошо: параллельные вызовы через CompletableFuture
public OrderDetails getOrderDetails(String orderId) {
    CompletableFuture<Order> orderFuture = 
        CompletableFuture.supplyAsync(() -> apiClient.getOrder(orderId));
    
    CompletableFuture<OrderDetails> result = orderFuture.thenCompose(order ->
        CompletableFuture.allOf(
            CompletableFuture.supplyAsync(() -> apiClient.getUser(order.getUserId())),
            CompletableFuture.supplyAsync(() -> apiClient.getInventory(order.getItemId()))
        ).thenApply(v -> new OrderDetails(
            order,
            // получить результаты из завершённых future
        ))
    );
    
    return result.join();
}

Шаг 5: Оптимизация кэширования

Использование неправильного кэша может замедлить приложение:

from org.springframework.cache.annotation.Cacheable;

@Service
public class UserService {
    
    // Кэширование часто запрашиваемых пользователей
    @Cacheable("users", unless = "#result == null")
    public User getUserById(Long id) {
        // Дорогостоящий запрос
        return userRepository.findById(id).orElse(null);
    }
    
    // Кэширование с TTL (важно для свежести данных)
    @Cacheable(cacheNames = "activeUsers", cacheManager = "cacheManagerWithTTL")
    public List<User> getActiveUsers() {
        return userRepository.findAllActive();
    }
}

Шаг 6: Проверка использования памяти и Garbage Collection

Частые сборки мусора замораживают приложение:

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;

public class GCMonitor {
    public static void monitorGC() {
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.println("GC: " + gc.getName());
            System.out.println("Count: " + gc.getCollectionCount());
            System.out.println("Time: " + gc.getCollectionTime() + "ms");
        }
    }
}

// Оптимизация heap размера в application.properties
// -Xms512m -Xmx2g -XX:+UseG1GC

Шаг 7: Анализ использования потоков

Дедлоки или истощение thread pool замедляют обработку:

from org.springframework.boot.actuate.metrics.web.servlet.WebMvcTagsContributor;

@Configuration
public class ThreadPoolConfig {
    
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

// Мониторинг в контроллере
@RestController
public class MonitorController {
    @GetMapping("/threads")
    public Map<String, Object> getThreadInfo() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        return Map.of(
            "threadCount", threadBean.getThreadCount(),
            "peakThreadCount", threadBean.getPeakThreadCount(),
            "currentThreadCount", threadBean.getThreadCount()
        );
    }
}

Шаг 8: Использование Async обработки

Для долгих операций используй асинхронность:

@Service
public class OrderService {
    
    @Async
    public CompletableFuture<OrderReport> generateReport(String orderId) {
        // Долгая операция выполняется в отдельном потоке
        OrderReport report = buildReport(orderId);
        return CompletableFuture.completedFuture(report);
    }
}

// В контроллере
@RestController
public class OrderController {
    
    @GetMapping("/reports/{id}")
    public CompletableFuture<OrderReport> getReport(@PathVariable String id) {
        return orderService.generateReport(id);
    }
}

Инструменты для диагностики

• JProfiler — визуальное профилирование CPU и памяти
• YourKit — профайлер с поддержкой async операций
• Micrometer + Prometheus — метрики производительности
• Spring Boot Actuator — встроенные endpoint для мониторинга
• async-profiler — низкоуровневое профилирование

Чеклист оптимизации

• Проверить алгоритмическую сложность операций
• Оптимизировать работу с коллекциями
• Параллелизировать независимые операции
• Добавить кэширование где уместно
• Увеличить размер thread pool если нужно
• Настроить параметры GC
• Использовать async обработку для I/O операций
• Профилировать hot spots с помощью JVM tools