public class ConstantTimeExample {
    private int[] array;
    
    public int getElement(int index) {
        // Всегда выполняется за фиксированное время
        return array[index];
    }
    
    public boolean isEven(int number) {
        // Математическая операция также O(1)
        return number % 2 == 0;
    }
}

public class BinarySearch {
    public static int search(int[] sortedArray, int target) {
        int left = 0;
        int right = sortedArray.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2; // Избегаем переполнения
            
            if (sortedArray[mid] == target) {
                return mid;
            } else if (sortedArray[mid] < target) {
                left = mid + 1; // Отбрасываем левую половину
            } else {
                right = mid - 1; // Отбрасываем правую половину
            }
        }
        return -1; // Элемент не найден
    }
}

public class LinearTimeExample {
    public static int findMax(int[] array) {
        if (array.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }
        
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

public class MergeSort {
    public static void sort(int[] array) {
        if (array.length <= 1) return;
        
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        
        sort(left);
        sort(right);
        
        merge(array, left, right);
    }
    
    private static void merge(int[] result, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result[k++] = left[i++];
            } else {
                result[k++] = right[j++];
            }
        }
        
        while (i < left.length) result[k++] = left[i++];
        while (j < right.length) result[k++] = right[j++];
    }
}

public class BubbleSort {
    public static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // Обмен элементов
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

public class ExponentialExample {
    // Наивная рекурсивная реализация Фибоначчи: O(2ⁿ)
    public static long fibonacciNaive(int n) {
        if (n <= 1) return n;
        return fibonacciNaive(n - 1) + fibonacciNaive(n - 2);
    }
    
    // Динамическое программирование: O(n)
    public static long fibonacciDP(int n) {
        if (n <= 1) return n;
        
        long[] fib = new long[n + 1];
        fib[0] = 0;
        fib[1] = 1;
        
        for (int i = 2; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        
        return fib[n];
    }
}

public class QuickSort {
    public static void sort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }
    
    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // Разделение массива
            int pivotIndex = partition(array, low, high);
            
            // Рекурсивная сортировка частей
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, high);
        }
    }
    
    private static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // Выбор опорного элемента
        int i = low - 1;
        
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                swap(array, i, j);
            }
        }
        
        swap(array, i + 1, high);
        return i + 1;
    }
    
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

public class OptimizedQuickSort {
    private static final int INSERTION_THRESHOLD = 16;
    
    public static void sort(int[] array) {
        randomizedQuickSort(array, 0, array.length - 1);
    }
    
    private static void randomizedQuickSort(int[] array, int low, int high) {
        // Для маленьких массивов используем сортировку вставками
        if (high - low < INSERTION_THRESHOLD) {
            insertionSort(array, low, high);
            return;
        }
        
        // Рандомизированный выбор опорного элемента
        int randomIndex = low + (int)(Math.random() * (high - low + 1));
        swap(array, randomIndex, high);
        
        int pivotIndex = partition(array, low, high);
        randomizedQuickSort(array, low, pivotIndex - 1);
        randomizedQuickSort(array, pivotIndex + 1, high);
    }
}

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));
    }
}