Что такое ограничение ресурсов?

Ограничение ресурсов

Ограничение ресурсов (Resource Limits) - это механизм контроля и управления количеством вычислительных ресурсов (CPU, память, дисковое пространство, подключения к БД, сетевые соединения и т.д.), которые может использовать приложение или сервис. Это критично для надёжности, масштабируемости и безопасности систем.

Основные концепции

Проблема без ограничений: если приложение может использовать неограниченные ресурсы, оно может исчерпать ресурсы сервера, что приведёт к отказу в обслуживании (DoS).

Решение через ограничения: установка верхних границ на использование ресурсов предотвращает крах системы и обеспечивает справедливое распределение.

Типы ограничений в Java приложениях

1. Ограничение Heap памяти (JVM)

Controllирует максимальное количество памяти, которое может использовать Java приложение:

# Запуск Java приложения с ограничениями памяти
java -Xms1G -Xmx2G MyApplication
# -Xms = начальный размер heap (1GB)
# -Xmx = максимальный размер heap (2GB)

Это предотвращает OutOfMemoryError и неконтролируемый рост памяти.

2. Ограничение пула потоков (Thread Pool)

Ограничивает количество потоков, которые могут одновременно обрабатывать запросы:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolLimitExample {
    
    public static void main(String[] args) {
        // Создаём пул с максимум 10 потоками
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // Отправляем задачи - всё что больше 10, будет в очереди
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                // Обработка задачи
                System.out.println("Processing task");
            });
        }
        
        executor.shutdown();
    }
}

3. Ограничение подключений к БД (Connection Pool)

Ограничивает количество одновременных подключений к базе данных:

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class DatabaseConfig {
    
    public static void main(String[] args) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
        config.setUsername("user");
        config.setPassword("password");
        
        // Ограничения
        config.setMaximumPoolSize(20);        // Макс 20 подключений
        config.setMinimumIdle(5);             // Мин 5 idle подключений
        config.setConnectionTimeout(30000);   // 30 сек таймаут
        config.setIdleTimeout(600000);        // 10 мин таймаут для idle
        config.setMaxLifetime(1800000);       // 30 мин макс жизнь
        
        HikariDataSource dataSource = new HikariDataSource(config);
        
        // Использование
        try (var connection = dataSource.getConnection()) {
            // Выполняем запрос
        }
    }
}

Без ограничений пул может исчерпать лимит подключений БД и заблокировать приложение.

4. Ограничение Rate Limiting (запросов в секунду)

Ограничивает количество запросов, которые пользователь может отправить:

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.Bucket4j;
import io.github.bucket4j.Refill;
import java.time.Duration;

public class RateLimitingExample {
    
    public static void main(String[] args) {
        // Позволяем 100 запросов в минуту
        Bandwidth limit = Bandwidth.classic(100, Refill.intervally(
            100,
            Duration.ofMinutes(1)
        ));
        Bucket bucket = Bucket4j.builder()
            .addLimit(limit)
            .build();
        
        // Проверяем каждый запрос
        for (int i = 0; i < 150; i++) {
            if (bucket.tryConsume(1)) {
                System.out.println("Request #" + i + " allowed");
            } else {
                System.out.println("Request #" + i + " REJECTED (rate limit exceeded)");
            }
        }
    }
}

В Spring можно использовать аннотацию:

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/search")
public class SearchController {
    
    @GetMapping
    @RateLimit(limit = 10, window = 60)  // 10 запросов в минуту
    public List<Product> search(@RequestParam String query) {
        return searchService.find(query);
    }
}

5. Ограничение время выполнения (Timeout)

Ограничивает время, которое может занять операция:

import java.util.concurrent.*;

public class TimeoutExample {
    
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        
        Future<String> future = executor.submit(() -> {
            // Долгая операция
            Thread.sleep(5000);
            return "Result";
        });
        
        try {
            // Ждём результат максимум 2 секунды
            String result = future.get(2, TimeUnit.SECONDS);
            System.out.println(result);
        } catch (TimeoutException e) {
            System.out.println("Operation timed out!");
            future.cancel(true);  // Отменяем операцию
        }
    }
}

В Spring Data JPA:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query(value = "SELECT * FROM users WHERE status = ?1", timeout = 5)
    List<User> findActiveUsers(String status);
    // Если запрос займёт больше 5 секунд, выбросит исключение
}

6. Ограничение памяти на операцию

Ограничивает кэш или временное хранилище:

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.LoadingCache;
import java.util.concurrent.TimeUnit;

public class CacheWithLimits {
    
    private final LoadingCache<String, Data> cache = CacheBuilder.newBuilder()
        .maximumSize(1000)                    // Макс 1000 записей
        .expireAfterWrite(10, TimeUnit.MINUTES) // Истекает через 10 мин
        .concurrencyLevel(4)                  // Внутренние блокировки
        .build(key -> loadData(key));
    
    private Data loadData(String key) {
        // Загружаем данные
        return new Data(key);
    }
}

Ограничения на уровне контейнера (Docker/Kubernetes)

Docker

# Ограничиваем контейнер
docker run \
  --memory="512m" \              # Макс 512 МБ памяти
  --cpus="1.5" \                 # Макс 1.5 CPU cores
  --pids-limit=100 \             # Макс 100 процессов
  my-java-app

Kubernetes

apiVersion: v1
kind: Pod
metadata:
  name: java-app
spec:
  containers:
  - name: app
    image: my-java-app:latest
    resources:
      requests:        # Минимум требуемых ресурсов
        cpu: 500m      # 0.5 CPU
        memory: 256Mi   # 256 МБ
      limits:          # Максимум ресурсов
        cpu: 1000m     # 1 CPU
        memory: 512Mi   # 512 МБ

Пример: Полнофункциональное приложение с ограничениями

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import com.zaxxer.hikari.HikariDataSource;

@SpringBootApplication
public class ApplicationWithLimits {
    
    // 1. Ограничение пула потоков для async операций
    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);        // Начальные потоки
        executor.setMaxPoolSize(20);        // Макс потоки
        executor.setQueueCapacity(100);     // Размер очереди
        executor.setThreadNamePrefix("async-");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }
    
    // 2. Ограничение для HTTP клиента
    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);      // Таймаут подключения
        factory.setReadTimeout(10000);        // Таймаут чтения
        
        // Ограничение пула соединений
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create()
            .setMaxConnTotal(100)             // Всего соединений
            .setMaxConnPerRoute(20);          // На каждый хост
        
        factory.setHttpClient(httpClientBuilder.build());
        return new RestTemplate(factory);
    }
    
    public static void main(String[] args) {
        // Ограничение JVM памяти
        // Запуск: java -Xms256m -Xmx512m -jar app.jar
        SpringApplication.run(ApplicationWithLimits.class, args);
    }
}

Мониторинг использования ресурсов

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

public class ResourceMonitoring {
    
    public static void printResourceUsage() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        
        long heapUsed = memoryBean.getHeapMemoryUsage().getUsed() / (1024 * 1024);
        long heapMax = memoryBean.getHeapMemoryUsage().getMax() / (1024 * 1024);
        int threadCount = threadBean.getThreadCount();
        int threadMax = threadBean.getPeakThreadCount();
        
        System.out.println("Heap Memory: " + heapUsed + "MB / " + heapMax + "MB");
        System.out.println("Thread Count: " + threadCount + " (peak: " + threadMax + ")");
        
        if (heapUsed > heapMax * 0.8) {
            System.err.println("WARNING: Heap usage above 80%!");
        }
    }
}

Best Practices

1. Устанавливай разумные ограничения: не слишком жёсткие, но и не неограниченные
2. Мониторь использование: регулярно проверяй метрики
3. Тестируй под нагрузкой: найди точку насыщения
4. Используй graceful shutdown: дай приложению время на корректное завершение
5. Документируй ограничения: чтобы все знали, какие границы установлены
6. Алерты: настрой оповещения при превышении лимитов на 80%

Ограничение ресурсов - это критичная часть проектирования надёжных приложений. Правильная конфигурация лимитов предотвращает крахи и обеспечивает стабильность системы под нагрузкой.