public class Task090126 {
    public static void main(String[] args) {
        int n = 10;
        int count = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j += i) {
                count++;
            }
        }
        System.out.println(count);
    }
}

rabbitmq_queue_messages_ready        # Сообщения, готовые к доставке
rabbitmq_queue_messages_unacked      # Сообщения в процессе обработки
rabbitmq_queue_consumers             # Количество потребителей
rabbitmq_process_open_fds            # Открытые файловые дескрипторы
rabbitmq_erlang_gc_reclaimed_bytes   # Память, освобождённая сборщиком мусора

// Концептуальный пример расширенной проверки
@Component
public class RabbitMQBusinessHealthIndicator {
    
    public Health checkBusinessReadiness() {
        // Проверяем не только соединение, но и:
        // 1. Наличие критических очередей
        // 2. Наличие активных потребителей
        // 3. Разумную глубину очередей
        // 4. Скорость обработки сообщений
    }
}

Важный принцип: Health checks должны проверять не только доступность RabbitMQ, но и способность вашего приложения эффективно с ним взаимодействовать.

# Конфигурация Spring Retry
spring:
  rabbitmq:
    listener:
      simple:
        retry:
          enabled: true
          max-attempts: 3
          initial-interval: 1s
          multiplier: 2
          max-interval: 10s

// Фильтр для HTTP запросов
@Component
public class CorrelationIdFilter implements Filter {
    
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) {
        // Извлекаем или генерируем correlation ID
        // Помещаем в MDC для логирования
        // Добавляем в заголовки RabbitMQ сообщений
    }
}

// MessagePostProcessor для RabbitMQ
@Component  
public class CorrelationIdMessagePostProcessor implements MessagePostProcessor {
    
    public Message postProcessMessage(Message message) {
        // Добавляем correlation ID из MDC в заголовки сообщения
        return message;
    }
}

Важно: Correlation ID должен передаваться через все асинхронные границы — HTTP запросы, сообщения RabbitMQ, вызовы внешних API.

<appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <customFields>{"application":"${APP_NAME}"}</customFields>
    </encoder>
</appender>

HTTP Request → [Span A] → RabbitMQ Publish → [Span B]
                                  ↓
                           (сообщение в очереди)
                                  ↓
                          RabbitMQ Consume → [Span C] → DB Call → [Span D]

Важно: Даже при асинхронной коммуникации через RabbitMQ можно сохранить контекст трассировки, передавая traceId и spanId в заголовках сообщений.

public class Task120126 {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;
        int e = 128;

        System.out.println(a == b);
        System.out.println(c == d);
        System.out.println(c == e);
        System.out.println(c.equals(e));
    }
}

public class InputMemoryExample {
    // Метод суммирует элементы массива
    // Память: O(n) для хранения входного массива
    public static int sumArray(int[] array) {
        int sum = 0;
        for (int value : array) {
            sum += value;
        }
        return sum;
    }
    
    // Метод создает копию массива
    // Память: O(n) для входных данных + O(n) для копии = O(n)
    public static int[] copyAndModify(int[] array) {
        int[] copy = new int[array.length]; // Дополнительная память O(n)
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i] * 2;
        }
        return copy;
    }
}

public class AuxiliaryStructures {
    // Алгоритм поиска двух чисел с заданной суммой
    // Версия 1: Без дополнительной памяти, но O(n²) времени
    public static int[] findPairNaive(int[] array, int targetSum) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] + array[j] == targetSum) {
                    return new int[]{array[i], array[j]};
                }
            }
        }
        return null; // Память: O(1) вспомогательной
    }
    
    // Версия 2: С хеш-таблицей, O(n) времени, но O(n) памяти
    public static int[] findPairOptimized(int[] array, int targetSum) {
        Set<Integer> seen = new HashSet<>(); // Вспомогательная структура O(n)
        for (int num : array) {
            int complement = targetSum - num;
            if (seen.contains(complement)) {
                return new int[]{complement, num};
            }
            seen.add(num);
        }
        return null;
    }
}

public class RecursionMemory {
    // Рекурсивное вычисление факториала
    // Пространственная сложность: O(n) из-за глубины рекурсии
    public static long factorialRecursive(int n) {
        if (n <= 1) return 1;
        return n * factorialRecursive(n - 1); // Каждый вызов добавляет фрейм в стек
    }
    
    // Итеративное вычисление факториала
    // Пространственная сложность: O(1)
    public static long factorialIterative(int n) {
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }
    
    // Рекурсивный обход дерева в глубину (DFS)
    // Пространственная сложность: O(h), где h - высота дерева
    public static void dfs(TreeNode node) {
        if (node == null) return;
        
        // Обработка узла
        System.out.println(node.value);
        
        // Рекурсивный обход детей
        dfs(node.left);
        dfs(node.right);
        
        // В худшем случае (вырожденное дерево) h = n, сложность O(n)
        // В сбалансированном дереве h = log n, сложность O(log n)
    }
}

public class HashTableAnalysis {
    // HashMap обеспечивает в среднем O(1) для операций put, get, remove
    // Но требует значительной дополнительной памяти
    public static void hashTableDemo() {
        Map<String, Integer> hashMap = new HashMap<>(1000);
        
        // Вставка: вычисление хеша O(1) + обработка коллизий
        hashMap.put("key1", 100);
        hashMap.put("key2", 200);
        
        // Поиск: вычисление хеша O(1) + доступ к bucket
        Integer value = hashMap.get("key1");
        
        // Память: массив buckets (capacity) + узлы для пар ключ-значение
        // Коэффициент загрузки (load factor) по умолчанию 0.75
        // При capacity=16 и 12 элементах массив будет расширен
    }
}