Как повысить производительность, если ничего лишнего пользователю не передается

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

Когда данные минимальные, фокусируемся на коде

Если уже передаём только необходимые данные (нет N+1 queries, нет лишних полей), оптимизируем сам код.

1. Алгоритмическая сложность (самое важное)

Первое — выбираем правильный алгоритм:

// ❌ O(n²) — медленно
public boolean hasDuplicate(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) return true;
        }
    }
    return false;
}

// ✅ O(n) — быстро
public boolean hasDuplicate(int[] arr) {
    Set<Integer> seen = new HashSet<>();
    for (int num : arr) {
        if (!seen.add(num)) return true;
    }
    return false;
}

// Ускорение: 10000 элементов
// O(n²): 100 миллионов операций
// O(n): 10000 операций = 10000x быстрее

2. Структуры данных (правильный выбор инструмента)

// ❌ ArrayList для частых поисков
List<User> users = new ArrayList<>();
boolean found = users.contains(user);  // O(n)

// ✅ HashSet для поисков
Set<User> users = new HashSet<>();
boolean found = users.contains(user);  // O(1)

// Для отсортированного доступа:
// TreeMap/TreeSet: O(log n)
// HashMap: O(1) средний случай
// ArrayList: O(n) поиск, но O(1) доступ по индексу

3. Избегаем создания объектов (GC pressure)

Каждый new объект — это работа для Garbage Collector:

// ❌ Создаём объект в цикле
public long sumPrices(List<Product> products) {
    long total = 0;
    for (Product p : products) {
        Price price = new Price(p.getPrice());  // GC работа
        total += price.getValue();
    }
    return total;
}

// ✅ Используем примитивы где возможно
public long sumPrices(List<Product> products) {
    long total = 0;
    for (Product p : products) {
        total += p.getPrice();  // Нет allocation
    }
    return total;
}

// ✅ Object pool для часто используемых объектов
public class ConnectionPool {
    private Queue<Connection> available = new ConcurrentLinkedQueue<>();
    private int maxSize = 100;
    
    public Connection getConnection() {
        Connection conn = available.poll();
        if (conn == null) {
            conn = new Connection();  // Создаём только если нужно
        }
        return conn;
    }
    
    public void releaseConnection(Connection conn) {
        available.offer(conn);  // Возвращаем в пул
    }
}

4. Кеширование (правильное использование)

// ❌ Пересчитываем каждый раз
public int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n-1) + fibonacci(n-2);  // Экспоненциальная сложность
}

// ✅ Мемоизация
private static Map<Integer, Integer> cache = new HashMap<>();

public int fibonacci(int n) {
    if (cache.containsKey(n)) {
        return cache.get(n);
    }
    
    int result;
    if (n <= 1) {
        result = n;
    } else {
        result = fibonacci(n-1) + fibonacci(n-2);
    }
    
    cache.put(n, result);
    return result;
}

// ✅ Локальный кеш с @Cacheable
@Service
public class UserService {
    
    @Cacheable("users")
    public User findById(UUID id) {
        // Выполнится только первый раз
        return userRepository.findById(id);
    }
}

5. Параллельная обработка (многопоточность)

// ❌ Обрабатываем последовательно
public long processItems(List<Item> items) {
    return items.stream()
        .map(this::processItem)
        .reduce(0L, Long::sum);
}

// ✅ Параллельная обработка
public long processItems(List<Item> items) {
    return items.parallelStream()
        .map(this::processItem)
        .reduce(0L, Long::sum);
}

// ✅ Контролируемый ThreadPool
public long processItems(List<Item> items) {
    ExecutorService executor = Executors.newFixedThreadPool(4);
    
    List<Future<Long>> futures = items.stream()
        .map(item -> executor.submit(() -> processItem(item)))
        .collect(Collectors.toList());
    
    long total = 0;
    for (Future<Long> future : futures) {
        total += future.get();
    }
    
    executor.shutdown();
    return total;
}

6. String операции (часто узкое место)

// ❌ Конкатенация в цикле (создаёт новый String каждый раз)
public String buildCSV(List<String> items) {
    String result = "";
    for (String item : items) {
        result += item + ",";  // O(n) операция, O(n²) всего
    }
    return result;
}

// ✅ StringBuilder
public String buildCSV(List<String> items) {
    StringBuilder sb = new StringBuilder();
    for (String item : items) {
        sb.append(item).append(",");
    }
    return sb.toString();  // O(n) всего
}

// ✅ Stream + String.join (самый читаемый)
public String buildCSV(List<String> items) {
    return String.join(",", items);
}

7. Lazy evaluation (ленивые вычисления)

// ❌ Вычисляем всё сразу
public List<User> filterAndSort(List<User> users) {
    return users.stream()
        .filter(u -> expensiveCheck(u))  // Проверяем всех
        .map(u -> enrichUser(u))         // Обогащаем всех
        .sorted(Comparator.comparing(User::getName))
        .limit(10)  // Но нужны только 10
        .collect(Collectors.toList());
}

// ✅ Stream вычисляет лениво (только для 10 нужных)
public List<User> filterAndSort(List<User> users) {
    return users.stream()
        .filter(u -> expensiveCheck(u))
        .map(u -> enrichUser(u))
        .sorted(Comparator.comparing(User::getName))
        .limit(10)  // Останавливает как найдены 10
        .collect(Collectors.toList());
}

8. Database layer optimization

// ❌ N+1 query проблема
public List<UserDTO> getUsers() {
    List<User> users = userRepository.findAll();  // 1 запрос
    return users.stream()
        .map(user -> new UserDTO(
            user.getName(),
            userRepository.getOrders(user.getId())  // N запросов!
        ))
        .collect(Collectors.toList());
}

// ✅ Fetch join (один запрос со всем)
@Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

public List<UserDTO> getUsers() {
    return userRepository.findAllWithOrders().stream()
        .map(user -> new UserDTO(user.getName(), user.getOrders()))
        .collect(Collectors.toList());
}

9. JVM настройки для production

# Правильно установить heap
java -Xmx2g -Xms2g MyApp  # Фиксированный размер быстрее

# Использовать современный GC
java -XX:+UseG1GC -Xmx2g MyApp  # G1GC масштабируется хорошо

# Агрессивный JIT
java -XX:+AggressiveOpts -XX:+UseFastAccessorMethods MyApp

10. Профилирование (найти реальные узкие места)

# Профилировать время выполнения методов
java -cp myapp.jar:. MyApp

# Использовать JProfiler или YourKit
# Находим где реально тратится время

Порядок оптимизации

1. Профилируй — не гадай где медленно (Amdahl's Law)
2. Алгоритм — выбери O(n) вместо O(n²)
3. Структуры данных — HashMap вместо List для поиска
4. Кеш — сохраняй результаты дорогих операций
5. Параллелизм — распредели на процессоры
6. Микрооптимизации — StringBuilder вместо конкатенации

Помни: Преждевременная оптимизация — корень всех зол. Сначала profile, потом optimize.